static apt_bool_t task_test_run(apt_test_suite_t *suite, int argc, const char * const *argv)
{
apt_task_t *task;
apt_task_vtable_t *vtable;
apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Create Task");
task = apt_task_create(NULL,NULL,suite->pool);
if(!task) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Create Task");
return FALSE;
}
vtable = apt_task_vtable_get(task);
if(vtable) {
vtable->run = task_main;
}
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Start Task");
if(apt_task_start(task) == FALSE) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Start Task");
apt_task_destroy(task);
return FALSE;
}
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Wait for Task to Complete");
apt_task_wait_till_complete(task);
apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Destroy Task");
apt_task_destroy(task);
return TRUE;
}
/** Open verification engine */
static apt_bool_t demo_verifier_engine_open(mrcp_engine_t *engine)
{
demo_verifier_engine_t *demo_engine = engine->obj;
if(demo_engine->task) {
apt_task_t *task = apt_consumer_task_base_get(demo_engine->task);
apt_task_start(task);
}
return mrcp_engine_open_respond(engine,TRUE);
}
/** Open synthesizer engine */
static apt_bool_t demo_synth_engine_open(mrcp_resource_engine_t *engine)
{
demo_synth_engine_t *demo_engine = engine->obj;
if(demo_engine->task) {
apt_task_t *task = apt_consumer_task_base_get(demo_engine->task);
apt_task_start(task);
}
return TRUE;
}
/** Create demo framework */
demo_framework_t* demo_framework_create(apt_dir_layout_t *dir_layout)
{
demo_framework_t *framework = NULL;
mrcp_client_t *client = unimrcp_client_create(dir_layout);
if(client) {
demo_application_t *demo_application;
apr_pool_t *pool = mrcp_client_memory_pool_get(client);
/* create demo framework */
framework = apr_palloc(pool,sizeof(demo_framework_t));
framework->pool = pool;
framework->client = client;
framework->application_table = apr_hash_make(pool);
/* create demo synthesizer application */
demo_application = demo_synth_application_create(framework->pool);
if(demo_application) {
demo_framework_app_register(framework,demo_application,"synth");
}
/* create demo recognizer application */
demo_application = demo_recog_application_create(framework->pool);
if(demo_application) {
demo_framework_app_register(framework,demo_application,"recog");
}
/* create demo bypass media application */
demo_application = demo_bypass_application_create(framework->pool);
if(demo_application) {
demo_framework_app_register(framework,demo_application,"bypass");
}
/* create demo resource discover application */
demo_application = demo_discover_application_create(framework->pool);
if(demo_application) {
demo_framework_app_register(framework,demo_application,"discover");
}
demo_framework_consumer_task_create(framework);
if(framework->task) {
apt_task_t *task = apt_consumer_task_base_get(framework->task);
apt_task_start(task);
}
/* start client stack */
mrcp_client_start(client);
}
return framework;
}
static apt_bool_t consumer_task_test_run(apt_test_suite_t *suite, int argc, const char * const *argv)
{
apt_consumer_task_t *consumer_task;
apt_task_t *task;
apt_task_vtable_t *vtable;
apt_task_msg_pool_t *msg_pool;
apt_task_msg_t *msg;
sample_msg_data_t *data;
int i;
msg_pool = apt_task_msg_pool_create_dynamic(sizeof(sample_msg_data_t),suite->pool);
apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Create Consumer Task");
consumer_task = apt_consumer_task_create(NULL,msg_pool,suite->pool);
if(!consumer_task) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Create Consumer Task");
return FALSE;
}
task = apt_consumer_task_base_get(consumer_task);
vtable = apt_task_vtable_get(task);
if(vtable) {
vtable->process_msg = task_msg_process;
vtable->on_start_complete = task_on_start_complete;
vtable->on_terminate_complete = task_on_terminate_complete;
}
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Start Task");
if(apt_task_start(task) == FALSE) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Start Task");
apt_task_destroy(task);
return FALSE;
}
for(i=0; i<10; i++) {
msg = apt_task_msg_acquire(msg_pool);
msg->type = TASK_MSG_USER;
data = (sample_msg_data_t*) msg->data;
data->number = i;
data->timestamp = apr_time_now();
apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Signal Message [%d]",data->number);
apt_task_msg_signal(task,msg);
}
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Terminate Task [wait till complete]");
apt_task_terminate(task,TRUE);
apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Destroy Task");
apt_task_destroy(task);
return TRUE;
}
/** Start message processing loop */
MRCP_DECLARE(apt_bool_t) mrcp_server_start(mrcp_server_t *server)
{
apt_task_t *task;
if(!server || !server->task) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Invalid Server");
return FALSE;
}
task = apt_consumer_task_base_get(server->task);
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Start Server Task");
if(apt_task_start(task) == FALSE) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Start Server Task");
return FALSE;
}
return TRUE;
}
/** Start message processing loop */
MRCP_DECLARE(apt_bool_t) mrcp_client_start(mrcp_client_t *client)
{
apt_task_t *task;
if(!client || !client->task) {
apt_log(APT_PRIO_WARNING,"Invalid Client");
return FALSE;
}
task = apt_consumer_task_base_get(client->task);
apt_log(APT_PRIO_INFO,"Start Client Task");
if(apt_task_start(task) == FALSE) {
apt_log(APT_PRIO_WARNING,"Failed to Start Client Task");
return FALSE;
}
return TRUE;
}
/** Start message processing loop */
MRCP_DECLARE(apt_bool_t) mrcp_client_start(mrcp_client_t *client)
{
apt_bool_t sync_start = TRUE;
apt_task_t *task;
if(!client || !client->task) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Invalid Client");
return FALSE;
}
task = apt_consumer_task_base_get(client->task);
if(client->on_start_complete) {
sync_start = FALSE;
}
if(sync_start == TRUE) {
/* get prepared to start stack synchronously */
apr_thread_mutex_create(&client->sync_start_mutex,APR_THREAD_MUTEX_DEFAULT,client->pool);
apr_thread_cond_create(&client->sync_start_object,client->pool);
apr_thread_mutex_lock(client->sync_start_mutex);
}
if(apt_task_start(task) == FALSE) {
if(sync_start == TRUE) {
apr_thread_mutex_unlock(client->sync_start_mutex);
}
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Start Client Task");
return FALSE;
}
if(sync_start == TRUE) {
/* wait for start complete */
apr_thread_cond_wait(client->sync_start_object,client->sync_start_mutex);
apr_thread_mutex_unlock(client->sync_start_mutex);
}
return TRUE;
}
bool UmcFramework::CreateTask()
{
apt_task_t* pTask;
apt_task_vtable_t* pVtable;
apt_task_msg_pool_t* pMsgPool;
pMsgPool = apt_task_msg_pool_create_dynamic(sizeof(UmcTaskMsg),m_pPool);
m_pTask = apt_consumer_task_create(this,pMsgPool,m_pPool);
if(!m_pTask)
return false;
pTask = apt_consumer_task_base_get(m_pTask);
apt_task_name_set(pTask,"Framework Agent");
pVtable = apt_consumer_task_vtable_get(m_pTask);
if(pVtable)
{
pVtable->process_msg = UmcProcessMsg;
pVtable->on_start_complete = UmcOnStartComplete;
pVtable->on_terminate_complete = UmcOnTerminateComplete;
}
apt_task_start(pTask);
return true;
}
/** Start connection agent. */
MRCP_DECLARE(apt_bool_t) mrcp_client_connection_agent_start(mrcp_connection_agent_t *agent)
{
return apt_task_start(agent->task);
}
/** Start connection task. */
APT_DECLARE(apt_bool_t) apt_net_client_task_start(apt_net_client_task_t *task)
{
return apt_task_start(task->base);
}
/** Run MPF test suite */
static apt_bool_t mpf_test_run(apt_test_suite_t *suite, int argc, const char * const *argv)
{
mpf_suite_agent_t *agent;
mpf_codec_manager_t *codec_manager;
mpf_rtp_config_t *rtp_config;
mpf_rtp_settings_t *rtp_settings;
mpf_engine_t *engine;
apt_task_t *task;
apt_task_vtable_t *vtable;
apt_task_msg_pool_t *msg_pool;
agent = apr_palloc(suite->pool,sizeof(mpf_suite_agent_t));
agent->dir_layout = apt_default_dir_layout_create(NULL,suite->pool);
engine = mpf_engine_create("MPF-Engine",suite->pool);
if(!engine) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Create MPF Engine");
return FALSE;
}
codec_manager = mpf_engine_codec_manager_create(suite->pool);
if(!codec_manager) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Create Codec Manager");
return FALSE;
}
mpf_engine_codec_manager_register(engine,codec_manager);
agent->engine = engine;
rtp_config = mpf_rtp_config_alloc(suite->pool);
apt_string_set(&rtp_config->ip,"127.0.0.1");
rtp_config->rtp_port_min = 5000;
rtp_config->rtp_port_max = 6000;
agent->rtp_config = rtp_config;
rtp_settings = mpf_rtp_settings_alloc(suite->pool);
rtp_settings->ptime = 20;
rtp_settings->jb_config.adaptive = 1;
rtp_settings->jb_config.time_skew_detection = 1;
rtp_settings->jb_config.min_playout_delay = 0;
rtp_settings->jb_config.initial_playout_delay = 50;
rtp_settings->jb_config.max_playout_delay = 800;
mpf_codec_manager_codec_list_load(codec_manager,&rtp_settings->codec_list,"PCMU",suite->pool);
agent->rtp_settings = rtp_settings;
agent->rtp_termination_factory = mpf_rtp_termination_factory_create(rtp_config,suite->pool);
agent->file_termination_factory = mpf_file_termination_factory_create(suite->pool);
agent->rx_session = NULL;
agent->tx_session = NULL;
msg_pool = apt_task_msg_pool_create_dynamic(sizeof(mpf_message_t),suite->pool);
apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Create Consumer Task");
agent->consumer_task = apt_consumer_task_create(agent,msg_pool,suite->pool);
if(!agent->consumer_task) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Create Consumer Task");
return FALSE;
}
task = apt_consumer_task_base_get(agent->consumer_task);
apt_task_name_set(task,"MPF-Tester");
vtable = apt_task_vtable_get(task);
if(vtable) {
vtable->process_msg = mpf_suite_task_msg_process;
vtable->on_start_complete = mpf_suite_on_start_complete;
vtable->on_terminate_complete = mpf_suite_on_terminate_complete;
}
apt_task_add(task,mpf_task_get(engine));
apr_thread_mutex_create(&agent->wait_object_mutex,APR_THREAD_MUTEX_UNNESTED,suite->pool);
apr_thread_cond_create(&agent->wait_object,suite->pool);
if(apt_task_start(task) == FALSE) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Start Task");
apt_task_destroy(task);
return FALSE;
}
apr_thread_mutex_lock(agent->wait_object_mutex);
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Wait for Task to Complete");
apr_thread_cond_wait(agent->wait_object,agent->wait_object_mutex);
apr_thread_mutex_unlock(agent->wait_object_mutex);
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Terminate Task [wait till complete]");
apt_task_terminate(task,TRUE);
apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Destroy Task");
apt_task_destroy(task);
apr_thread_cond_destroy(agent->wait_object);
apr_thread_mutex_destroy(agent->wait_object_mutex);
return TRUE;
}
/** Start poller task */
APT_DECLARE(apt_bool_t) apt_poller_task_start(apt_poller_task_t *task)
{
return apt_task_start(task->base);
}
/** Run MPF test suite */
static apt_bool_t mpf_test_run(apt_test_suite_t *suite, int argc, const char * const *argv)
{
mpf_suite_engine_t *suite_engine;
mpf_codec_manager_t *codec_manager;
mpf_rtp_config_t *config;
mpf_engine_t *engine;
apt_task_t *task;
apt_task_vtable_t *vtable;
apt_task_msg_pool_t *msg_pool;
suite_engine = apr_palloc(suite->pool,sizeof(mpf_suite_engine_t));
engine = mpf_engine_create(suite->pool);
if(!engine) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Create MPF Engine");
return FALSE;
}
codec_manager = mpf_engine_codec_manager_create(suite->pool);
if(codec_manager) {
mpf_engine_codec_manager_register(engine,codec_manager);
}
suite_engine->engine = engine;
config = mpf_rtp_config_alloc(suite->pool);
apt_string_set(&config->ip,"127.0.0.1");
config->rtp_port_min = 5000;
config->rtp_port_min = 6000;
suite_engine->rtp_termination_factory = mpf_rtp_termination_factory_create(config,suite->pool);
suite_engine->file_termination_factory = mpf_file_termination_factory_create(suite->pool);
msg_pool = apt_task_msg_pool_create_dynamic(sizeof(mpf_message_t),suite->pool);
apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Create Consumer Task");
suite_engine->consumer_task = apt_consumer_task_create(suite_engine,msg_pool,suite->pool);
if(!suite_engine->consumer_task) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Create Consumer Task");
return FALSE;
}
task = apt_consumer_task_base_get(suite_engine->consumer_task);
vtable = apt_task_vtable_get(task);
if(vtable) {
vtable->process_msg = mpf_suite_task_msg_process;
vtable->on_start_complete = mpf_suite_on_start_complete;
vtable->on_terminate_complete = mpf_suite_on_terminate_complete;
}
apt_task_add(task,mpf_task_get(engine));
apr_thread_mutex_create(&suite_engine->wait_object_mutex,APR_THREAD_MUTEX_UNNESTED,suite->pool);
apr_thread_cond_create(&suite_engine->wait_object,suite->pool);
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Start Task");
if(apt_task_start(task) == FALSE) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Start Task");
apt_task_destroy(task);
return FALSE;
}
apr_thread_mutex_lock(suite_engine->wait_object_mutex);
apr_thread_cond_wait(suite_engine->wait_object,suite_engine->wait_object_mutex);
apr_thread_mutex_unlock(suite_engine->wait_object_mutex);
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Terminate Task [wait till complete]");
apt_task_terminate(task,TRUE);
apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Destroy Task");
apt_task_destroy(task);
apr_thread_cond_destroy(suite_engine->wait_object);
apr_thread_mutex_destroy(suite_engine->wait_object_mutex);
return TRUE;
}