engine_name = strdup(TTS_SERVER_ENGINE_DEFAULT);
}
+ SLOG(LOG_ERROR, TAG_TTSC, "[INFO] Current default engine (%s)", engine_name);
+
return engine_name;
}
return NULL;
}
+ SLOG(LOG_ERROR, TAG_TTSC, "[INFO] Get engine info (%s)", engine_id);
+
for (GSList* iter = g_slist_nth(g_engine_list, 0); NULL != iter; iter = g_slist_next(iter)) {
tts_engine_info_s* engine_info = iter->data;
if (NULL == engine_info) {
return NULL;
}
+ SLOG(LOG_ERROR, TAG_TTSC, "[INFO] Get voice info. language(%s), voice type(%d)", language, voice_type);
+
for (GSList* iter = g_slist_nth(engine_info->voices, 0); NULL != iter; iter = g_slist_next(iter)) {
tts_config_voice_s* voice = iter->data;
if (NULL == voice) {
}
if (TTS_CONFIG_VOICE_TYPE_NONE == voice_type || voice_type == voice->type) {
- SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Success to find voice : %s, %d", language, voice_type);
+ SLOG(LOG_INFO, TAG_TTSCONFIG, "Success to find voice : %s, %d", language, voice_type);
return voice;
}
}
if (TTS_CONFIG_VOICE_TYPE_NONE != voice_type) {
config_info->type = voice_type;
}
+
+ SLOG(LOG_ERROR, TAG_TTSC, "[INFO] Set voice into config info. language(%s), voice type(%d)", config_info->language, config_info->type);
}
int __tts_config_mgr_check_engine_is_valid(const char* engine_id)
}
if (0 >= g_slist_length(g_engine_list)) {
- SLOG(LOG_ERROR, TAG_TTSCONFIG, "There is no engine!!");
+ SLOG(LOG_ERROR, TAG_TTSCONFIG, "There is no engine(%s)!!", engine_id);
return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
}
if (NULL != engine_info->uuid) {
vconf_set_str(TTS_ENGINE_DB_DEFAULT, engine_info->uuid);
+ SLOG(LOG_INFO, TAG_TTSCONFIG, "[INFO] Change the default engine as a valid engine(%s)", engine_info->uuid);
}
}
strncpy(config_info.setting, engine_info->setting, sizeof(g_setting) - 1);
}
- SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Default engine is changed : %s", config_info.engine_id);
+ SLOG(LOG_ERROR, TAG_TTSCONFIG, "[INFO] Default engine is changed : %s", config_info.engine_id);
/* Change is default voice */
tts_config_voice_s* voice = __get_voice_info(engine_info, config_info.language, config_info.type);
}
set_voice_into_config(&config_info, voice->language, voice->type);
- SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Default voice is changed : lang(%s) type(%d)", voice->language, voice->type);
+ SLOG(LOG_ERROR, TAG_TTSCONFIG, "[INFO] Default voice is changed : lang(%s) type(%d)", voice->language, voice->type);
if (__is_client_type(TTS_CONFIG_CLIENT_TYPE_SETTING | TTS_CONFIG_CLIENT_TYPE_SERVER | TTS_CONFIG_CLIENT_TYPE_INTERRUPT)) {
if (0 != tts_parser_set_engine(config_info.engine_id, config_info.setting, config_info.language, config_info.type)) {
return false;
}
+ SLOG(LOG_ERROR, TAG_TTSCONFIG, "[INFO] engine_id(%s), language(%s), type(%d)", engine_id, language, type);
+
tts_engine_info_s *engine_info = __get_engine_info(engine_id);
if (NULL == engine_info) {
SLOG(LOG_ERROR, TAG_TTSCONFIG, "engine info is NULL");
*language = strdup(voice->language);
*type = voice->type;
- SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Selected language(%s) type(%d)", *language, *type);
+ SLOG(LOG_ERROR, TAG_TTSCONFIG, "[INFO] Selected language(%s) type(%d)", *language, *type);
return TTS_CONFIG_ERROR_NONE;
}
engine_changed_cb_parameter_s *params = (engine_changed_cb_parameter_s *)data;
if (NULL != params) {
SLOG(LOG_DEBUG, TAG_TTSCONFIG, "@@@ Config changed callback event");
- SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Engine change(%s)", params->engine_id);
+ SECURE_SLOG(LOG_ERROR, TAG_TTSCONFIG, "Engine change(%s)", params->engine_id);
g_slist_foreach(g_config_client_list, invoke_engine_changed_cb, params);
release_engine_changed_cb_params(params);
return;
}
+ SLOG(LOG_ERROR, TAG_TTSCONFIG, "[INFO] Voice changed callback. before_language(%s), before_voice_type(%d), current_language(%s), current_voice_type(%d), auto_voice(%d)", params->before_language, params->before_voice_type, params->current_language, params->current_voice_type, params->auto_voice);
+
if (NULL != client->voice_cb) {
SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Voice changed callback : uid(%u)", client->uid);
client->voice_cb(params->before_language, params->before_voice_type, params->current_language,
voice_changed_cb_parameter_s *params = (voice_changed_cb_parameter_s *)data;
if (NULL != params) {
SLOG(LOG_DEBUG, TAG_TTSCONFIG, "@@@ Config changed callback event");
- SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Voice change(%s, %d)", params->current_language, params->current_voice_type);
+ SECURE_SLOG(LOG_ERROR, TAG_TTSCONFIG, "[DEBUG] Voice change from(%s, %d) to(%s, %d)", params->before_language, params->before_voice_type, params->current_language, params->current_voice_type);
g_slist_foreach(g_config_client_list, invoke_voice_changed_cb, params);
release_voice_changed_cb_params(params);
params->current_language = strdup(current_language);
params->current_voice_type = current_voice_type;
params->auto_voice = auto_voice;
+
+ SLOG(LOG_ERROR, TAG_TTSCONFIG, "[INFO] Voice changed event. before_language(%s), before_voice_type(%d), current_language(%s), current_voice_type(%d), auto_voice(%d)", params->before_language, params->before_voice_type, params->current_language, params->current_voice_type, params->auto_voice);
+
g_voice_changed_event_idler = ecore_idler_add(invoke_voice_changed_event_by_idler, params);
}
free(setting);
}
- SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Engine change(%s)", config_info.engine_id);
+ SLOG(LOG_ERROR, TAG_TTSCONFIG, "[INFO] Engine change(%s)", config_info.engine_id);
/* Call all callbacks of client*/
invoke_engine_changed_event(config_info.engine_id, config_info.setting, config_info.language, config_info.type, config_info.auto_voice, config_info.credential);
if (auto_voice != config_info.auto_voice) {
config_info.auto_voice = auto_voice;
}
+ SLOG(LOG_ERROR, TAG_TTSCONFIG, "[INFO] config: auto_voice(%d)", (int)config_info.auto_voice);
if (NULL != lang || TTS_CONFIG_VOICE_TYPE_NONE != voice_type) {
char* before_lang = strdup(config_info.language);
int before_type = config_info.type;
set_voice_into_config(&config_info, lang, voice_type);
- SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Voice change(%s, %d)", config_info.language, config_info.type);
+ SLOG(LOG_ERROR, TAG_TTSCONFIG, "[INFO] Voice change(%s, %d)", config_info.language, config_info.type);
/* Call all callbacks of client*/
if (NULL != before_lang) {
if (-1 != speech_rate) {
config_info.speech_rate = speech_rate;
- SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Speech rate change(%d)", config_info.speech_rate);
+ SLOG(LOG_ERROR, TAG_TTSCONFIG, "[INFO] Speech rate change(%d)", config_info.speech_rate);
/* Call all callbacks of client*/
invoke_speech_rate_changed_event(config_info.speech_rate);
if (-1 != pitch) {
config_info.pitch = pitch;
- SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "pitch change(%d)", config_info.pitch);
+ SLOG(LOG_ERROR, TAG_TTSCONFIG, "[INFO] Pitch change(%d)", config_info.pitch);
/* Call all callbacks of client*/
invoke_pitch_changed_event(config_info.pitch);
if (0.0 <= bg_volume_ratio) {
config_info.bg_volume_ratio = bg_volume_ratio;
- SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "background volume ratio change(%lf)", config_info.bg_volume_ratio);
+ SLOG(LOG_ERROR, TAG_TTSCONFIG, "[INFO] Background volume ratio change(%lf)", config_info.bg_volume_ratio);
/* Call all callbacks of client*/
invoke_bg_volume_ratio_changed_event(config_info.bg_volume_ratio);
SLOG(LOG_ERROR, TAG_TTSCONFIG, "[Config ERROR] Fail to get display language");
return TTS_CONFIG_ERROR_OPERATION_FAILED;
}
+ SLOG(LOG_ERROR, TAG_TTSCONFIG, "[INFO] Current display language(%s)", display_language);
char selected_language[6] = {'\0', };
strncpy(selected_language, display_language, sizeof(selected_language) - 1);
display_language = NULL;
int selected_type = config_info.type;
+ SLOG(LOG_ERROR, TAG_TTSCONFIG, "[INFO] Seletected language(%s), selected type(%d)", selected_language, selected_type);
if (false == __tts_config_mgr_check_lang_is_valid(config_info.engine_id, selected_language, selected_type)) {
/* Display language is not valid */
char* tmp_language = NULL;
strncpy(selected_language, tmp_language, sizeof(selected_language) - 1);
free(tmp_language);
tmp_language = NULL;
+ SLOG(LOG_ERROR, TAG_TTSCONFIG, "[INFO] Seletected language(%s), selected type(%d)", selected_language, selected_type);
}
- SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[Config] Select default voice : lang(%s) type(%d)", selected_language, selected_type);
+ SLOG(LOG_ERROR, TAG_TTSCONFIG, "[Config INFO] Select default voice : lang(%s) type(%d)", selected_language, selected_type);
if (__is_client_type(allowed_type_flag)) {
if (0 != tts_parser_set_voice(selected_language, selected_type)) {
SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to save config");
}
invoke_voice_changed_event(config_info.language, config_info.type, selected_language, selected_type, config_info.auto_voice);
+ SLOG(LOG_ERROR, TAG_TTSCONFIG, "[INFO] voice changed event was invoked. language(%s), type(%d), selected language(%s), selected type(%d), auto_voice(%d)", config_info.language, config_info.type, selected_language, selected_type, (int)config_info.auto_voice);
} else {
SLOG(LOG_INFO, TAG_TTSCONFIG, "Client is not allowed to save configuration. Skip saving configuration file.");
}
return;
}
+ SLOG(LOG_ERROR, TAG_TTSCONFIG, "[INFO] Changed screen reader (%d)", screen_reader);
+
GSList *iter = NULL;
tts_config_client_s* temp_client = NULL;
if (0 != ret) {
SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to set voice");
} else {
- SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[DEBUG] Saved default voice : lang(%s), type(%d)", temp_lang, temp_type);
+ SLOG(LOG_ERROR, TAG_TTSCONFIG, "[DEBUG] Saved default voice : lang(%s), type(%d)", temp_lang, temp_type);
}
if (NULL != temp_lang) {
free(temp_lang);
}
/* Check language is valid */
+ SECURE_SLOG(LOG_ERROR, TAG_TTSCONFIG, "[Config INFO] Select default voice : lang(%s) type(%d)", language, type);
if (__is_client_type(TTS_CONFIG_CLIENT_TYPE_SETTING | TTS_CONFIG_CLIENT_TYPE_SERVER | TTS_CONFIG_CLIENT_TYPE_INTERRUPT)) {
if (0 != tts_parser_set_voice(language, type)) {
SLOG(LOG_ERROR, TAG_TTSCONFIG, "Fail to save default voice");
return false;
}
+ SLOG(LOG_ERROR, TAG_TTSCONFIG, "[INFO] Check default voice is valid. engine_id(%s), language(%s), type(%d)", config_info.engine_id, language, type);
+
return __tts_config_mgr_check_lang_is_valid(config_info.engine_id, language, type);
}
if (0 >= g_slist_length(g_engine_list)) {
SLOG(LOG_DEBUG, TAG_TTSCONFIG, "-------------- engine list -----------------");
- SLOG(LOG_DEBUG, TAG_TTSCONFIG, " No Engine in engine directory");
+ SLOG(LOG_ERROR, TAG_TTSCONFIG, " No Engine in engine directory");
SLOG(LOG_DEBUG, TAG_TTSCONFIG, "--------------------------------------------");
return TTS_CONFIG_ERROR_NONE;
}
}
*size = engine_info->text_size;
- SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[DEBUG] Max text size is %d.", *size);
+ SLOG(LOG_ERROR, TAG_TTSCONFIG, "[DEBUG] Max text size is %d.", *size);
return TTS_CONFIG_ERROR_NONE;
}
int tts_parser_set_config_info(tts_config_s* config_info)
{
- SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[DEBUG] Set config info");
+ SLOG(LOG_ERROR, TAG_TTSCONFIG, "[DEBUG] Set config info");
if (NULL == config_info) {
SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] config_info is NULL");
return -1;
SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Parameter is NULL");
}
+ SLOG(LOG_ERROR, TAG_TTSCONFIG, "[INFO] Set value into config. key(%s), value(%s)", key, value);
+
xmlNodePtr cur = NULL;
cur = xmlDocGetRootElement(g_config_doc);
if (cur == NULL) {
if (0 == xmlStrcmp(cur->name, (const xmlChar *)key)) {
xmlNodeSetContent(cur, (const xmlChar *)value);
- SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Set key(%s) : value(%s)", key, value);
+ SLOG(LOG_ERROR, TAG_TTSCONFIG, "[INFO] Set key(%s) : value(%s)", key, value);
break;
}
{
int ret = xmlSaveFile(TTS_CONFIG, config_doc);
if (0 > ret) {
- SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Save result : file(%s), ret(%d)", TTS_CONFIG, ret);
+ SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Save result : file(%s), ret(%d) errno(%d)", TTS_CONFIG, ret, errno);
} else {
static FILE* pFile;
pFile = fopen(TTS_CONFIG, "r");
return -1;
}
+ SLOG(LOG_ERROR, TAG_TTSCONFIG, "[INFO] Set voice. language(%s), type(%d)", language, type);
+
if (0 != __set_value_into_configuration(TTS_TAG_CONFIG_LANGUAGE, language)) {
return -1;
}
int tts_parser_set_auto_voice(bool value)
{
char* temp = value ? "on" : "off";
+
+ SLOG(LOG_ERROR, TAG_TTSCONFIG, "[INFO] Set auto voice (%d)", (int)value);
+
if (0 != __set_value_into_configuration(TTS_TAG_CONFIG_AUTO_VOICE, temp)) {
return -1;
}
memset(temp, '\0', 10);
snprintf(temp, 10, "%d", value);
+ SLOG(LOG_ERROR, TAG_TTSCONFIG, "[INFO] Set speech rate (%d)", value);
+
if (0 != __set_value_into_configuration(TTS_TAG_CONFIG_SPEECH_RATE, temp)) {
return -1;
}
memset(temp, '\0', 10);
snprintf(temp, 10, "%d", value);
+ SLOG(LOG_ERROR, TAG_TTSCONFIG, "[INFO] Set pitch (%d)", value);
+
if (0 != __set_value_into_configuration(TTS_TAG_CONFIG_PITCH, temp)) {
return -1;
}
memset(temp, '\0', 10);
snprintf(temp, 10, "%d", (int)(value * VOLUME_BASE_VALUE));
+ SLOG(LOG_ERROR, TAG_TTSCONFIG, "[INFO] Set background volume ratio (%lf)", value);
+
if (0 != __set_value_into_configuration(TTS_TAG_CONFIG_BACKGROUND_VOLUME_RATIO, temp)) {
return -1;
}
int ttsd_engine_agent_load_current_engine()
{
- SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent DEBUG] load current engine START");
+ SLOG(LOG_INFO, tts_tag(), "[Engine Agent] load current engine START");
if (false == __is_agent_initialized()) {
SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Not Initialized");
/* Select default voice */
if (NULL != g_engine_info->default_lang) {
bool is_valid = false;
+ SLOG(LOG_ERROR, tts_tag(), "[Engine Agent INFO] Current g_engine_info. default_lang(%s), default_vctype(%d)", g_engine_info->default_lang, g_engine_info->default_vctype);
+
ret = g_engine_info->callbacks->is_valid_voice(g_engine_info->default_lang, g_engine_info->default_vctype, &is_valid);
if (0 == ret) {
if (true == is_valid) {
- SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent SUCCESS] Set origin default voice to current engine : lang(%s), type(%d)",
+ SLOG(LOG_INFO, tts_tag(), "[Engine Agent SUCCESS] Set origin default voice to current engine : lang(%s), type(%d)",
g_engine_info->default_lang, g_engine_info->default_vctype);
} else {
SLOG(LOG_WARN, tts_tag(), "[Engine Agent WARNING] Fail to set origin default voice : lang(%s), type(%d)",
}
/* load default voice */
+ SLOG(LOG_ERROR, tts_tag(), "[Engine Agent INFO] Current g_engine_info. default_lang(%s), default_vctype(%d)", g_engine_info->default_lang, g_engine_info->default_vctype);
ret = g_engine_info->callbacks->load_voice(g_engine_info->default_lang, g_engine_info->default_vctype);
if (0 == ret) {
- SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent SUCCESS] Load default voice : lang(%s), type(%d)",
+ SLOG(LOG_INFO, tts_tag(), "[Engine Agent SUCCESS] Load default voice : lang(%s), type(%d)",
g_engine_info->default_lang, g_engine_info->default_vctype);
} else {
SLOG(LOG_WARN, tts_tag(), "[Engine Agent ERROR] Fail to load default voice : lang(%s), type(%d) result(%s)",
return false;
}
- SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent] Select voice : input lang(%s), input type(%d), input ptts_id(%s), default lang(%s), default type(%d)",
+ SLOG(LOG_ERROR, tts_tag(), "[Engine Agent] Select voice : input lang(%s), input type(%d), input ptts_id(%s), default lang(%s), default type(%d)",
(NULL == lang) ? "NULL" : lang, type, (NULL == ptts_id) ? "NULL" : ptts_id, (NULL == g_engine_info->default_lang) ? "NULL" : g_engine_info->default_lang, g_engine_info->default_vctype);
/* case 1 : Both are default */
}
}
+ SLOG(LOG_ERROR, tts_tag(), "[Engine Agent] Selected voice : lang(%s), type(%d)", *out_lang, *out_type);
+
if (true == result) {
if (NULL != ptts_id)
SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent] Selected voice : lang(%s), type(%d), ptts_id(%s)", *out_lang, *out_type, *out_ptts_id);
if (NULL != data) {
if (NULL != data->lang && 0 == strcmp(data->lang, lang) && data->type == vctype) {
- SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent] Find voice : default(%d) loaded(%d) ref(%d) lang(%s) type(%d)",
+ SLOG(LOG_ERROR, tts_tag(), "[Engine Agent] Find voice : default(%d) loaded(%d) ref(%d) lang(%s) type(%d)",
data->is_default, data->is_loaded, data->client_ref_count, data->lang, data->type);
break;
}
return ret;
}
+ SLOG(LOG_ERROR, tts_tag(), "[Engine Agent] Set default voice : lang(%s), type(%d)", language, vctype);
+
bool is_valid = false;
ret = g_engine_info->callbacks->is_valid_voice(language, vctype, &is_valid);
if (0 == ret) {
if (true == is_valid) {
- SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent SUCCESS] Current voice is valid : lang(%s), type(%d)",
+ SLOG(LOG_ERROR, tts_tag(), "[Engine Agent SUCCESS] Current voice is valid : lang(%s), type(%d)",
(NULL == g_engine_info->default_lang) ? "NULL" : g_engine_info->default_lang, g_engine_info->default_vctype);
} else {
SLOG(LOG_WARN, tts_tag(), "[Engine Agent WARNING] Current voice is invalid : lang(%s), type(%d)",
/* load voice */
ret = g_engine_info->callbacks->load_voice(data->lang, data->type);
if (0 == ret) {
- SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent SUCCESS] load voice : lang(%s), type(%d)",
+ SLOG(LOG_ERROR, tts_tag(), "[Engine Agent SUCCESS] load voice : lang(%s), type(%d)",
data->lang, data->type);
data->is_loaded = true;
} else {
- SECURE_SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Fail to load voice : lang(%s), type(%d), result(%s)",
+ SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Fail to load voice : lang(%s), type(%d), result(%s)",
data->lang, data->type, __ttsd_get_engine_error_code(ret));
}
}
/* Unload voice */
ret = g_engine_info->callbacks->unload_voice(data->lang, data->type);
if (0 == ret) {
- SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent SUCCESS] Unload voice : lang(%s), type(%d)",
+ SLOG(LOG_ERROR, tts_tag(), "[Engine Agent SUCCESS] Unload voice : lang(%s), type(%d)",
data->lang, data->type);
data->is_loaded = false;
} else {
- SECURE_SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Fail to unload voice : lang(%s), type(%d), result(%s)",
+ SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Fail to unload voice : lang(%s), type(%d), result(%s)",
data->lang, data->type, __ttsd_get_engine_error_code(ret));
}
}
ttsd_print_voicelist();
#endif
- SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent SUCCESS] Set default voice : lang(%s), type(%d)",
+ SECURE_SLOG(LOG_ERROR, tts_tag(), "[Engine Agent SUCCESS] Set default voice : lang(%s), type(%d)",
g_engine_info->default_lang, g_engine_info->default_vctype);
return TTSD_ERROR_NONE;
}
return TTSD_ERROR_INVALID_VOICE;
} else {
- SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent] Start synthesis : language(%s), type(%d), ptts_id(%s), speed(%d), text(%s), credential(%s)",
+ SECURE_SLOG(LOG_ERROR, tts_tag(), "[Engine Agent DEBUG] Start synthesis : language(%s), type(%d), ptts_id(%s), speed(%d), text(%s), credential(%s)",
(NULL == temp_lang) ? "NULL" : temp_lang, temp_type, (NULL == temp_ptts_id) ? "NULL" : temp_ptts_id, speed, (NULL == text) ? "NULL" : text, (NULL == credential) ? "NULL" : credential);
}