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

static void switch_channel_wait_for_state_or_greater(switch_channel_t *channel, switch_channel_t *other_channel, switch_channel_state_t want_state){	switch_assert(channel);		for (;;) {		if ((switch_channel_get_state(channel) < CS_HANGUP && 			 switch_channel_get_state(channel) == switch_channel_get_running_state(channel) && switch_channel_get_running_state(channel) >= want_state) ||			(other_channel && switch_channel_down_nosig(other_channel)) || switch_channel_down(channel)) {			break;		}		switch_cond_next();	}}

static switch_status_t limit_state_handler(switch_core_session_t *session){	switch_channel_t *channel = switch_core_session_get_channel(session);	switch_channel_state_t state = switch_channel_get_state(channel);	const char *vval = switch_channel_get_variable(channel, LIMIT_IGNORE_TRANSFER_VARIABLE);	const char *backendlist = switch_channel_get_variable(channel, LIMIT_BACKEND_VARIABLE);		if (zstr(backendlist)) {		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Unset limit backendlist!/n");		return SWITCH_STATUS_SUCCESS;	}	if (state >= CS_HANGUP || (state == CS_ROUTING && !switch_true(vval))) {		int argc = 0;		char *argv[6] = { 0 };		char *mydata = strdup(backendlist);		int x;				argc = switch_separate_string(mydata, ',', argv, (sizeof(argv) / sizeof(argv[0])));		for (x = 0; x < argc; x++) {			switch_limit_release(argv[x], session, NULL, NULL);		}		switch_core_event_hook_remove_state_change(session, limit_state_handler);		/* Remove limit_backend variable so we register another hook if limit is called again */		switch_channel_set_variable(channel, LIMIT_BACKEND_VARIABLE, NULL);				free(mydata);	}		return SWITCH_STATUS_SUCCESS;}

/** * Start execution of call output component * @param component to start * @param session the session to output to * @param output the output request * @param iq the original request */static iks *start_call_output(struct rayo_component *component, switch_core_session_t *session, iks *output, iks *iq){	switch_stream_handle_t stream = { 0 };	/* acknowledge command */	rayo_component_send_start(component, iq);	/* build playback command */	SWITCH_STANDARD_STREAM(stream);	stream.write_function(&stream, "{id=%s,session=%s,pause=%s",		RAYO_JID(component), switch_core_session_get_uuid(session),		OUTPUT_COMPONENT(component)->start_paused ? "true" : "false");	if (OUTPUT_COMPONENT(component)->max_time > 0) {		stream.write_function(&stream, ",timeout=%i", OUTPUT_COMPONENT(component)->max_time * 1000);	}	stream.write_function(&stream, "}fileman://rayo://%s", RAYO_JID(component));	if (switch_ivr_displace_session(session, stream.data, 0, "m") == SWITCH_STATUS_SUCCESS) {		RAYO_UNLOCK(component);	} else {		if (OUTPUT_COMPONENT(component)->document) {			iks_delete(OUTPUT_COMPONENT(component)->document);		}		if (switch_channel_get_state(switch_core_session_get_channel(session)) >= CS_HANGUP) {			rayo_component_send_complete(component, COMPONENT_COMPLETE_HANGUP);			component = NULL;		} else {			rayo_component_send_complete(component, COMPONENT_COMPLETE_ERROR);			component = NULL;		}	}	switch_safe_free(stream.data);	return NULL;}

void fs_channel_set_state(switch_core_session_t *session, char *state){	switch_channel_t *channel = switch_core_session_get_channel(session);	switch_channel_state_t fs_state = switch_channel_get_state(channel);	if ((fs_state = switch_channel_name_state(state)) < CS_HANGUP) {		switch_channel_set_state(channel, fs_state);	}}

static switch_status_t loopback_bowout_on_execute_state_handler(switch_core_session_t *session){	switch_channel_t *channel = switch_core_session_get_channel(session);	switch_channel_state_t state = switch_channel_get_state(channel);	private_t *tech_pvt = NULL;	if (state == CS_EXECUTE) {		const char *uuid;		switch_core_session_t *other_session = NULL;		switch_channel_t *b_channel = NULL;		tech_pvt = switch_core_session_get_private(session);		if (switch_core_session_read_lock(tech_pvt->other_session) == SWITCH_STATUS_SUCCESS) {			b_channel = switch_core_session_get_channel(tech_pvt->other_session);			/* Wait for b_channel to be fully bridged */			switch_channel_wait_for_flag(b_channel, CF_BRIDGED, SWITCH_TRUE, 5000, NULL);			uuid = switch_channel_get_partner_uuid(b_channel);			if (uuid && (other_session = switch_core_session_locate(uuid))) {				switch_channel_t *other_channel = switch_core_session_get_channel(other_session);				switch_caller_profile_t *cp, *clone;				switch_channel_wait_for_state(other_channel, NULL, CS_EXCHANGE_MEDIA);				switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(tech_pvt->other_session), SWITCH_LOG_INFO, "Replacing loopback channel: %s with real channel: %s/n",								  switch_channel_get_name(b_channel), switch_channel_get_name(other_channel));				if ((cp = switch_channel_get_caller_profile(channel))) {					clone = switch_caller_profile_clone(other_session, cp);					clone->originator_caller_profile = NULL;					clone->originatee_caller_profile = NULL;					switch_channel_set_caller_profile(other_channel, clone);				}				switch_channel_caller_extension_masquerade(channel, other_channel, 0);				switch_channel_set_state(other_channel, CS_RESET);				switch_channel_wait_for_state(other_channel, NULL, CS_RESET);				switch_channel_set_variable(channel, "process_cdr", "false");				switch_channel_set_variable(b_channel, "process_cdr", "false");				switch_channel_hangup(channel, SWITCH_CAUSE_NORMAL_CLEARING);				switch_channel_set_state(other_channel, CS_EXECUTE);				switch_core_session_rwunlock(other_session);			}			switch_core_session_rwunlock(tech_pvt->other_session);		}				switch_core_event_hook_remove_state_change(session, loopback_bowout_on_execute_state_handler);	}	return SWITCH_STATUS_SUCCESS;}

SWITCH_DECLARE(const char *) CoreSession::getState(){	this_check(NULL);	if (channel) {		return switch_channel_state_name(switch_channel_get_state(channel));	}	return "ERROR";}

static void switch_core_standard_on_execute(switch_core_session_t *session){	switch_caller_extension_t *extension;	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Standard EXECUTE/n", switch_channel_get_name(session->channel));	if (switch_channel_get_variable(session->channel, "recovered") && !switch_channel_test_flag(session->channel, CF_RECOVERED)) {		switch_channel_set_flag(session->channel, CF_RECOVERED);	}  top:	switch_channel_clear_flag(session->channel, CF_RESET);		if ((extension = switch_channel_get_caller_extension(session->channel)) == 0) {		switch_channel_hangup(session->channel, SWITCH_CAUSE_NORMAL_CLEARING);		return;	}	while (switch_channel_get_state(session->channel) == CS_EXECUTE && extension->current_application) {		switch_caller_application_t *current_application = extension->current_application;		extension->current_application = extension->current_application->next;		if (switch_core_session_execute_application(session,													current_application->application_name,													current_application->application_data) != SWITCH_STATUS_SUCCESS) {			return;		}		if (switch_channel_test_flag(session->channel, CF_RESET)) {			goto top;		}	}	if (switch_channel_ready(session->channel) && switch_channel_get_state(session->channel) == CS_EXECUTE) {		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_NOTICE, "%s has executed the last dialplan instruction, hanging up./n",						  switch_channel_get_name(session->channel));		switch_channel_hangup(session->channel, SWITCH_CAUSE_NORMAL_CLEARING);	}}

static switch_status_t spy_on_park(switch_core_session_t *session){	switch_channel_t *channel = switch_core_session_get_channel(session);	const char *moh = switch_channel_get_variable(channel, "hold_music");	while (switch_channel_ready(channel) && switch_channel_get_state(channel) == CS_PARK) {		if (moh) {			switch_status_t status = switch_ivr_play_file(session, NULL, moh, NULL);			if (!SWITCH_READ_ACCEPTABLE(status)) {				break;			}		}	}	return SWITCH_STATUS_FALSE;}

SWITCH_DECLARE_NONSTD(switch_status_t) hanguphook(switch_core_session_t *session_hungup) {	switch_channel_t *channel = switch_core_session_get_channel(session_hungup);	CoreSession *coresession = NULL;	switch_channel_state_t state = switch_channel_get_state(channel);	if ((coresession = (CoreSession *) switch_channel_get_private(channel, "CoreSession"))) {		if (coresession->hook_state != state) {			coresession->hook_state = state;			coresession->check_hangup_hook();		}	}	return SWITCH_STATUS_SUCCESS;}

/** * Close SSML document. * @param handle * @return SWITCH_STATUS_SUCCESS */static switch_status_t rayo_file_close(switch_file_handle_t *handle){	struct rayo_file_context *context = (struct rayo_file_context *)handle->private_info;	if (context && context->component) {		struct output_component *output = OUTPUT_COMPONENT(context->component);		/* send completion and destroy */		if (output->stop) {			rayo_component_send_complete(context->component, COMPONENT_COMPLETE_STOP);		} else {			if (!strcmp(RAYO_ACTOR(context->component)->type, RAT_CALL_COMPONENT)) {				/* call output... check for hangup */				switch_core_session_t *session = switch_core_session_locate(RAYO_ACTOR(context->component)->parent->id);				if (session) {					if (switch_channel_get_state(switch_core_session_get_channel(session)) >= CS_HANGUP) {						rayo_component_send_complete(context->component, COMPONENT_COMPLETE_HANGUP);					} else {						rayo_component_send_complete(context->component, OUTPUT_FINISH);					}					switch_core_session_rwunlock(session);				} else {					/* session is gone */					rayo_component_send_complete(context->component, COMPONENT_COMPLETE_HANGUP);				}			} else {				/* mixer output... finished */				rayo_component_send_complete(context->component, OUTPUT_FINISH);			}		}		/* TODO timed out */		/* cleanup internals */		switch_safe_free(context->ssml);		context->ssml = NULL;		if (output->document) {			iks_delete(output->document);			output->document = NULL;		}		/* close SSML file */		if (switch_test_flag((&context->fh), SWITCH_FILE_OPEN)) {			return switch_core_file_close(&context->fh);		}	}	return SWITCH_STATUS_SUCCESS;}

static switch_status_t spy_on_park(switch_core_session_t *session){	switch_channel_t *channel = switch_core_session_get_channel(session);	const char *moh = switch_channel_get_hold_music(channel);	while (switch_channel_ready(channel) && switch_channel_get_state(channel) == CS_PARK) {		switch_status_t status = SWITCH_STATUS_SUCCESS;		if (moh) {			status = switch_ivr_play_file(session, NULL, moh, NULL);		} else {			status = switch_ivr_sleep(session, 10000, SWITCH_FALSE, NULL);		}		if (!SWITCH_READ_ACCEPTABLE(status)) {			break;		}	}	return SWITCH_STATUS_FALSE;}

SWITCH_DECLARE_NONSTD(switch_status_t) hanguphook(switch_core_session_t *session_hungup) {	if (session_hungup) {		switch_channel_t *channel = switch_core_session_get_channel(session_hungup);		CoreSession *coresession = NULL;		switch_channel_state_t state = switch_channel_get_state(channel);		if ((coresession = (CoreSession *) switch_channel_get_private(channel, "CoreSession"))) {			if (coresession->hook_state != state) {				coresession->cause = switch_channel_get_cause(channel);				coresession->hook_state = state;				coresession->check_hangup_hook();			}		}		return SWITCH_STATUS_SUCCESS;	} else {		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "hangup hook called with null session, something is horribly wrong/n");		return SWITCH_STATUS_FALSE;	}}

static switch_status_t my_on_reporting(switch_core_session_t *session){	switch_status_t status = SWITCH_STATUS_SUCCESS;	switch_channel_t *channel = switch_core_session_get_channel(session);	switch_event_header_t *hi;	switch_caller_profile_t *caller_profile;	switch_app_log_t *app_log;	bson cdr;	int is_b;	char *tmp;	if (globals.shutdown) {		return SWITCH_STATUS_SUCCESS;	}	is_b = channel && switch_channel_get_originator_caller_profile(channel);	if (!globals.log_b && is_b) {		const char *force_cdr = switch_channel_get_variable(channel, SWITCH_FORCE_PROCESS_CDR_VARIABLE);		if (!switch_true(force_cdr)) {			return SWITCH_STATUS_SUCCESS;		}	}	bson_init(&cdr);	/* Channel data */	bson_append_start_object(&cdr, "channel_data");	bson_append_string(&cdr, "state", switch_channel_state_name(switch_channel_get_state(channel)));	bson_append_string(&cdr, "direction", switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND ? "outbound" : "inbound");	bson_append_int(&cdr, "state_number", switch_channel_get_state(channel));	if ((tmp = switch_channel_get_flag_string(channel))) {		bson_append_string(&cdr, "flags", tmp);		free(tmp);	}	if ((tmp = switch_channel_get_cap_string(channel))) {		bson_append_string(&cdr, "caps", tmp);		free(tmp);	}	bson_append_finish_object(&cdr);				/* channel_data */	/* Channel variables */	bson_append_start_object(&cdr, "variables");	if ((hi = switch_channel_variable_first(channel))) {		for (; hi; hi = hi->next) {			if (!zstr(hi->name) && !zstr(hi->value)) {				bson_append_string(&cdr, hi->name, hi->value);			}		}		switch_channel_variable_last(channel);	}	bson_append_finish_object(&cdr);				/* variables */	/* App log */	if ((app_log = switch_core_session_get_app_log(session))) {		switch_app_log_t *ap;		bson_append_start_object(&cdr, "app_log");		for (ap = app_log; ap; ap = ap->next) {			bson_append_start_object(&cdr, "application");			bson_append_string(&cdr, "app_name", ap->app);			bson_append_string(&cdr, "app_data", ap->arg);			bson_append_long(&cdr, "app_stamp", ap->stamp);			bson_append_finish_object(&cdr);		/* application */		}		bson_append_finish_object(&cdr);			/* app_log */	}	/* Callflow */	caller_profile = switch_channel_get_caller_profile(channel);	while (caller_profile) {		bson_append_start_object(&cdr, "callflow");		if (!zstr(caller_profile->dialplan)) {			bson_append_string(&cdr, "dialplan", caller_profile->dialplan);		}		if (!zstr(caller_profile->profile_index)) {			bson_append_string(&cdr, "profile_index", caller_profile->profile_index);		}		if (caller_profile->caller_extension) {			switch_caller_application_t *ap;			bson_append_start_object(&cdr, "extension");			bson_append_string(&cdr, "name", caller_profile->caller_extension->extension_name);			bson_append_string(&cdr, "number", caller_profile->caller_extension->extension_number);			if (caller_profile->caller_extension->current_application) {				bson_append_string(&cdr, "current_app", caller_profile->caller_extension->current_application->application_name);			}//.........这里部分代码省略.........

static switch_status_t generate_json_cdr(switch_core_session_t *session, struct json_object **json_cdr){	struct json_object *cdr = json_object_new_object();	switch_channel_t *channel = switch_core_session_get_channel(session);	switch_caller_profile_t *caller_profile;	struct json_object *variables, *j_main_cp, *j_caller_profile, *j_caller_extension, *j_times, *time_tag,		*j_application, *j_callflow, *j_inner_extension, *j_apps, *j_o, *j_channel_data, *j_field;	switch_app_log_t *app_log;	char tmp[512], *f;		if (is_error(cdr)) {		return SWITCH_STATUS_FALSE;	}	j_channel_data = json_object_new_object();	if (is_error(j_channel_data)) {		goto error;	}	json_object_object_add(cdr, "channel_data", j_channel_data);		j_field = json_object_safe_new_string((char *) switch_channel_state_name(switch_channel_get_state(channel)));	json_object_object_add(j_channel_data, "state", j_field);	j_field = json_object_safe_new_string(switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND ? "outbound" : "inbound");	json_object_object_add(j_channel_data, "direction", j_field);	switch_snprintf(tmp, sizeof(tmp), "%d", switch_channel_get_state(channel));	j_field = json_object_new_string((char *) tmp);	json_object_object_add(j_channel_data, "state_number", j_field);		if ((f = switch_channel_get_flag_string(channel))) {		j_field = json_object_safe_new_string((char *) f);		json_object_object_add(j_channel_data, "flags", j_field);		free(f);	}	if ((f = switch_channel_get_cap_string(channel))) {		j_field = json_object_safe_new_string((char *) f);		json_object_object_add(j_channel_data, "caps", j_field);		free(f);	}	variables = json_object_new_object();	json_object_object_add(cdr, "variables", variables);	if (is_error(variables)) {		goto error;	}	set_json_chan_vars(variables, channel);	if ((app_log = switch_core_session_get_app_log(session))) {		switch_app_log_t *ap;		j_apps = json_object_new_object();		if (is_error(j_apps)) {			goto error;		}		json_object_object_add(cdr, "app_log", j_apps);		for (ap = app_log; ap; ap = ap->next) {			j_application = json_object_new_object();			if (is_error(j_application)) {				goto error;			}			json_object_object_add(j_application, "app_name", json_object_safe_new_string(ap->app));			json_object_object_add(j_application, "app_data", json_object_safe_new_string(ap->arg));			json_object_object_add(j_apps, "application", j_application);		}	}	caller_profile = switch_channel_get_caller_profile(channel);	while (caller_profile) {		j_callflow = json_object_new_object();		if (is_error(j_callflow)) {			goto error;		}		json_object_object_add(cdr, "callflow", j_callflow);		if (!zstr(caller_profile->dialplan)) {			json_object_object_add(j_callflow, "dialplan", json_object_safe_new_string((char *)caller_profile->dialplan));		}//.........这里部分代码省略.........