2 * Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 * http://www.apache.org/licenses/LICENSE-2.0
7 * Unless required by applicable law or agreed to in writing, software
8 * distributed under the License is distributed on an "AS IS" BASIS,
9 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
10 * See the License for the specific language governing permissions and
11 * limitations under the License.
17 #include <sys/inotify.h>
19 #include "tts_client.h"
20 #include "tts_config_mgr.h"
24 #include "tts_internal.h"
26 #define HELLO_WAITING_TIME 500
27 #define WAITING_TIME 5000
29 static DBusConnection* g_conn_sender = NULL;
30 static DBusConnection* g_conn_listener = NULL;
32 static Ecore_Fd_Handler* g_dbus_fd_handler = NULL;
35 extern int __tts_cb_error(int uid, tts_error_e reason, int utt_id, char *err_msg);
37 extern int __tts_cb_set_state(int uid, int state);
39 extern int __tts_cb_utt_started(int uid, int utt_id);
41 extern int __tts_cb_utt_completed(int uid, int utt_id);
44 static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
46 if (NULL == g_conn_listener) return ECORE_CALLBACK_RENEW;
48 dbus_connection_read_write_dispatch(g_conn_listener, 50);
51 DBusMessage* msg = NULL;
52 msg = dbus_connection_pop_message(g_conn_listener);
54 if (true != dbus_connection_get_is_connected(g_conn_listener)) {
55 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Connection is disconnected");
59 /* loop again if we haven't read a message */
65 dbus_error_init(&err);
67 char if_name[64] = {0, };
68 snprintf(if_name, 64, "%s", TTS_CLIENT_SERVICE_INTERFACE);
70 if (dbus_message_is_signal(msg, if_name, TTSD_METHOD_UTTERANCE_STARTED)) {
74 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INT32, &uttid, DBUS_TYPE_INVALID);
75 if (dbus_error_is_set(&err)) {
76 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get arguments error (%s)", err.message);
77 dbus_error_free(&err);
80 if (0 == __tts_cb_utt_started(uid, uttid)) {
81 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts utterance started : uid(%d) uttid(%d)", uid, uttid);
83 } /* TTSD_METHOD_UTTERANCE_STARTED */
85 else if (dbus_message_is_signal(msg, if_name, TTSD_METHOD_UTTERANCE_COMPLETED)) {
89 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INT32, &uttid, DBUS_TYPE_INVALID);
90 if (dbus_error_is_set(&err)) {
91 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get arguments error (%s)", err.message);
92 dbus_error_free(&err);
95 if (0 == __tts_cb_utt_completed(uid, uttid)) {
96 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts utterance completed : uid(%d) uttid(%d)", uid, uttid);
98 } /* TTS_SIGNAL_UTTERANCE_STARTED */
100 else if (dbus_message_is_signal(msg, if_name, TTSD_METHOD_SET_STATE)) {
104 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
105 if (dbus_error_is_set(&err)) {
106 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get arguments error (%s)", err.message);
107 dbus_error_free(&err);
110 if (0 == __tts_cb_set_state(uid, state)) {
111 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts state changed : uid(%d) state(%d)", uid, state);
113 } /* TTSD_SIGNAL_SET_STATE */
115 else if (dbus_message_is_signal(msg, if_name, TTSD_METHOD_ERROR)) {
121 dbus_message_get_args(msg, &err,
122 DBUS_TYPE_INT32, &uid,
123 DBUS_TYPE_INT32, &uttid,
124 DBUS_TYPE_INT32, &reason,
125 DBUS_TYPE_STRING, &err_msg,
128 if (dbus_error_is_set(&err)) {
129 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get Error message - Get arguments error (%s)", err.message);
130 dbus_error_free(&err);
132 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get Error message : uid(%d), error(%d), uttid(%d), err_msg(%s)", uid, reason, uttid, (NULL == err_msg) ? "NULL" : err_msg);
133 __tts_cb_error(uid, reason, uttid, err_msg);
136 } /* TTSD_SIGNAL_ERROR */
138 else if (dbus_message_is_signal(msg, "org.freedesktop.DBus", "NameOwnerChanged")) {
139 SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Owner Changed");
140 __tts_cb_error(-1, TTS_ERROR_SERVICE_RESET, -1, "Daemon Reset");
141 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
142 SLOG(LOG_DEBUG, TAG_TTSC, " ");
143 } /* NameOwnerChanged */
146 SLOG(LOG_DEBUG, TAG_TTSC, "Message is NOT valid");
147 dbus_message_unref(msg);
151 /* free the message */
152 dbus_message_unref(msg);
154 return ECORE_CALLBACK_PASS_ON;
157 static void __tts_dbus_connection_free()
159 if (NULL != g_conn_listener) {
160 dbus_connection_close(g_conn_listener);
161 dbus_connection_unref(g_conn_listener);
162 g_conn_listener = NULL;
164 if (NULL != g_conn_sender) {
165 dbus_connection_close(g_conn_sender);
166 dbus_connection_unref(g_conn_sender);
167 g_conn_sender = NULL;
171 int tts_dbus_open_connection()
173 if (NULL != g_conn_sender && NULL != g_conn_listener) {
174 SLOG(LOG_WARN, TAG_TTSC, "already existed connection ");
180 /* initialise the error value */
181 dbus_error_init(&err);
183 /* connect to the DBUS system bus, and check for errors */
184 g_conn_sender = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
185 if (dbus_error_is_set(&err)) {
186 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Dbus Connection Error (%s)", err.message);
187 dbus_error_free(&err);
190 if (NULL == g_conn_sender) {
191 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] fail to get dbus connection");
192 return TTS_ERROR_OPERATION_FAILED;
195 dbus_connection_set_exit_on_disconnect(g_conn_sender, false);
197 g_conn_listener = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
198 if (dbus_error_is_set(&err)) {
199 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Dbus Connection Error (%s)", err.message);
200 dbus_error_free(&err);
203 if (NULL == g_conn_listener) {
204 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] fail to get dbus connection for listener");
205 __tts_dbus_connection_free();
206 return TTS_ERROR_OPERATION_FAILED;
209 dbus_connection_set_exit_on_disconnect(g_conn_listener, false);
211 char rule[128] = {0, };
212 snprintf(rule, 128, "type='signal',interface='%s'", TTS_CLIENT_SERVICE_INTERFACE);
214 /* add a rule for which messages we want to see */
215 dbus_bus_add_match(g_conn_listener, rule, &err);
216 dbus_connection_flush(g_conn_listener);
219 if (true != dbus_connection_get_unix_fd(g_conn_listener, &fd)) {
220 SLOG(LOG_ERROR, TAG_TTSC, "Fail to get fd from dbus");
221 __tts_dbus_connection_free();
222 return TTS_ERROR_OPERATION_FAILED;
224 SLOG(LOG_DEBUG, TAG_TTSC, "Get fd from dbus : %d", fd);
227 g_dbus_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, NULL, NULL, NULL);
228 if (NULL == g_dbus_fd_handler) {
229 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get fd handler from ecore");
230 __tts_dbus_connection_free();
231 return TTS_ERROR_OPERATION_FAILED;
237 int tts_dbus_close_connection()
240 dbus_error_init(&err);
242 if (NULL != g_dbus_fd_handler) {
243 ecore_main_fd_handler_del(g_dbus_fd_handler);
244 g_dbus_fd_handler = NULL;
247 __tts_dbus_connection_free();
252 int tts_dbus_reconnect()
254 if (!g_conn_sender || !g_conn_listener) {
255 tts_dbus_close_connection();
257 if (0 != tts_dbus_open_connection()) {
258 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to reconnect");
262 SLOG(LOG_DEBUG, TAG_TTSC, "[DBUS] Reconnect");
266 bool sender_connected = dbus_connection_get_is_connected(g_conn_sender);
267 bool listener_connected = dbus_connection_get_is_connected(g_conn_listener);
268 SLOG(LOG_DEBUG, TAG_TTSC, "[DBUS] Sender(%s) Listener(%s)",
269 sender_connected ? "Connected" : "Not connected", listener_connected ? "Connected" : "Not connected");
271 if (false == sender_connected || false == listener_connected) {
272 tts_dbus_close_connection();
274 if (0 != tts_dbus_open_connection()) {
275 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to reconnect");
279 SLOG(LOG_DEBUG, TAG_TTSC, "[DBUS] Reconnect");
285 DBusMessage* __tts_dbus_make_message(int uid, const char* method)
287 if (NULL == method) {
288 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input method is NULL");
292 tts_client_s* client = tts_client_get_by_uid(uid);
295 if (NULL == client) {
296 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] uid is not available");
302 if (TTS_MODE_DEFAULT == client->mode) {
303 msg = dbus_message_new_method_call(
304 TTS_SERVER_SERVICE_NAME,
305 TTS_SERVER_SERVICE_OBJECT_PATH,
306 TTS_SERVER_SERVICE_INTERFACE,
308 } else if (TTS_MODE_NOTIFICATION == client->mode) {
309 msg = dbus_message_new_method_call(
310 TTS_NOTI_SERVER_SERVICE_NAME,
311 TTS_NOTI_SERVER_SERVICE_OBJECT_PATH,
312 TTS_NOTI_SERVER_SERVICE_INTERFACE,
314 } else if (TTS_MODE_SCREEN_READER == client->mode) {
315 msg = dbus_message_new_method_call(
316 TTS_SR_SERVER_SERVICE_NAME,
317 TTS_SR_SERVER_SERVICE_OBJECT_PATH,
318 TTS_SR_SERVER_SERVICE_INTERFACE,
320 } else if (TTS_MODE_INTERRUPT == client->mode) {
321 msg = dbus_message_new_method_call(
322 TTS_INTERRUPT_SERVER_SERVICE_NAME,
323 TTS_INTERRUPT_SERVER_SERVICE_OBJECT_PATH,
324 TTS_INTERRUPT_SERVER_SERVICE_INTERFACE,
327 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input mode is not available");
334 int tts_dbus_request_hello(int uid)
337 dbus_error_init(&err);
340 msg = __tts_dbus_make_message(uid, TTS_METHOD_HELLO);
342 if (dbus_error_is_set(&err)) {
343 // SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts dbus log : %s", err);
344 dbus_error_free(&err);
348 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts hello : Fail to make message");
349 return TTS_ERROR_OPERATION_FAILED;
352 DBusMessage* result_msg = NULL;
355 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, HELLO_WAITING_TIME, &err);
356 dbus_message_unref(msg);
357 if (dbus_error_is_set(&err)) {
358 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts dbus log : %s", err.message);
359 dbus_error_free(&err);
362 if (NULL != result_msg) {
363 dbus_message_unref(result_msg);
365 // SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts hello");
368 result = TTS_ERROR_TIMED_OUT;
374 int tts_dbus_request_initialize(int uid, bool* credential_needed)
378 dbus_error_init(&err);
380 msg = __tts_dbus_make_message(uid, TTS_METHOD_INITIALIZE);
383 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts initialize : Fail to make message");
384 return TTS_ERROR_OPERATION_FAILED;
386 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts initialize : uid(%d)", uid);
390 if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
391 dbus_message_unref(msg);
392 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
394 return TTS_ERROR_OPERATION_FAILED;
397 DBusMessage* result_msg;
398 int result = TTS_ERROR_OPERATION_FAILED;
400 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
401 dbus_message_unref(msg);
402 if (dbus_error_is_set(&err)) {
403 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
404 dbus_error_free(&err);
408 if (NULL != result_msg) {
409 dbus_message_get_args(result_msg, &err,
410 DBUS_TYPE_INT32, &result,
411 DBUS_TYPE_INT32, &temp,
414 if (dbus_error_is_set(&err)) {
415 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get arguments error (%s)", err.message);
416 dbus_error_free(&err);
417 result = TTS_ERROR_OPERATION_FAILED;
420 dbus_message_unref(result_msg);
423 *credential_needed = (bool)temp;
424 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts initialize : result = %d, credential_needed(%d)", result, *credential_needed);
426 /* add a rule for daemon error */
427 char rule_err[256] = {0, };
428 tts_client_s* client = tts_client_get_by_uid(uid);
429 if (NULL == client) {
430 SLOG(LOG_ERROR, TAG_TTSC, "Fail to get TTS client");
431 return TTS_ERROR_OPERATION_FAILED;
434 if (TTS_ERROR_SERVICE_RESET != client->reason) {
435 if (TTS_MODE_DEFAULT == client->mode) {
436 snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", TTS_SERVER_SERVICE_INTERFACE);
437 } else if (TTS_MODE_NOTIFICATION == client->mode) {
438 snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", TTS_NOTI_SERVER_SERVICE_INTERFACE);
439 } else if (TTS_MODE_SCREEN_READER == client->mode) {
440 snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", TTS_SR_SERVER_SERVICE_INTERFACE);
441 } else if (TTS_MODE_INTERRUPT == client->mode) {
442 snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", TTS_INTERRUPT_SERVER_SERVICE_INTERFACE);
444 dbus_bus_add_match(g_conn_listener, rule_err, &err);
445 dbus_connection_flush(g_conn_listener);
447 if (dbus_error_is_set(&err)) {
448 SLOG(LOG_ERROR, TAG_TTSC, "Match Error (%s)", err.message);
449 dbus_error_free(&err);
450 return TTS_ERROR_OPERATION_FAILED;
452 client->reason = 0; // default value
455 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts initialize : result = %d", result);
458 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
459 tts_dbus_reconnect();
460 result = TTS_ERROR_TIMED_OUT;
467 int tts_dbus_request_finalize(int uid)
471 dbus_error_init(&err);
473 /* remove a rule for daemon error */
474 char rule_err[256] = {0, };
475 tts_client_s* client = tts_client_get_by_uid(uid);
476 if (NULL == client) {
477 SLOG(LOG_ERROR, TAG_TTSC, "Fail to get TTS client");
478 return TTS_ERROR_OPERATION_FAILED;
481 if (TTS_MODE_DEFAULT == client->mode) {
482 snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", TTS_SERVER_SERVICE_INTERFACE);
483 } else if (TTS_MODE_NOTIFICATION == client->mode) {
484 snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", TTS_NOTI_SERVER_SERVICE_INTERFACE);
485 } else if (TTS_MODE_SCREEN_READER == client->mode) {
486 snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", TTS_SR_SERVER_SERVICE_INTERFACE);
487 } else if (TTS_MODE_INTERRUPT == client->mode) {
488 snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", TTS_INTERRUPT_SERVER_SERVICE_INTERFACE);
490 dbus_bus_remove_match(g_conn_listener, rule_err, &err);
491 dbus_connection_flush(g_conn_listener);
492 if (dbus_error_is_set(&err)) {
493 SLOG(LOG_ERROR, TAG_TTSC, "Match Error (%s)", err.message);
494 dbus_error_free(&err);
497 msg = __tts_dbus_make_message(uid, TTS_METHOD_FINALIZE);
500 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts finalize : Fail to make message");
501 return TTS_ERROR_OPERATION_FAILED;
503 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts finalize : uid(%d)", uid);
506 if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
507 dbus_message_unref(msg);
508 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
510 return TTS_ERROR_OPERATION_FAILED;
513 DBusMessage* result_msg;
514 int result = TTS_ERROR_OPERATION_FAILED;
516 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
517 dbus_message_unref(msg);
518 if (dbus_error_is_set(&err)) {
519 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error %s", err.message);
520 dbus_error_free(&err);
523 if (NULL != result_msg) {
524 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
526 if (dbus_error_is_set(&err)) {
527 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get arguments error (%s)", err.message);
528 dbus_error_free(&err);
529 result = TTS_ERROR_OPERATION_FAILED;
532 dbus_message_unref(result_msg);
535 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts finalize : result = %d", result);
537 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts finalize : result = %d", result);
540 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
541 tts_dbus_reconnect();
542 result = TTS_ERROR_TIMED_OUT;
548 int tts_dbus_request_add_text(int uid, const char* text, const char* lang, int vctype, int speed, int uttid, const char* credential)
550 if (NULL == text || NULL == lang) {
551 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
552 return TTS_ERROR_INVALID_PARAMETER;
557 dbus_error_init(&err);
559 msg = __tts_dbus_make_message(uid, TTS_METHOD_ADD_QUEUE);
562 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts add text : Fail to make message");
563 return TTS_ERROR_OPERATION_FAILED;
565 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts add text : uid(%d), text(%s), lang(%s), type(%d), speed(%d), id(%d), credential(%s)",
566 uid, text, lang, vctype, speed, uttid, (NULL == credential) ? "NULL" : credential);
570 if (NULL == credential) {
571 temp = strdup("NULL");
573 temp = strdup(credential);
576 if (true != dbus_message_append_args(msg,
577 DBUS_TYPE_INT32, &uid,
578 DBUS_TYPE_STRING, &text,
579 DBUS_TYPE_STRING, &lang,
580 DBUS_TYPE_INT32, &vctype,
581 DBUS_TYPE_INT32, &speed,
582 DBUS_TYPE_INT32, &uttid,
583 DBUS_TYPE_STRING, &temp,
584 DBUS_TYPE_INVALID)) {
585 dbus_message_unref(msg);
586 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
592 return TTS_ERROR_OPERATION_FAILED;
595 DBusMessage* result_msg;
596 int result = TTS_ERROR_OPERATION_FAILED;
598 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
599 dbus_message_unref(msg);
600 if (dbus_error_is_set(&err)) {
601 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
602 dbus_error_free(&err);
605 if (NULL != result_msg) {
606 dbus_message_get_args(result_msg, &err,
607 DBUS_TYPE_INT32, &result,
610 if (dbus_error_is_set(&err)) {
611 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts add text : Get arguments error (%s)", err.message);
612 dbus_error_free(&err);
613 result = TTS_ERROR_OPERATION_FAILED;
615 dbus_message_unref(result_msg);
618 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts add text : result(%d)", result);
620 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts add text : result(%d)", result);
623 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
624 tts_dbus_reconnect();
625 result = TTS_ERROR_TIMED_OUT;
635 int tts_dbus_request_set_private_data(int uid, const char* key, const char* data)
637 if (NULL == key || NULL == data) {
638 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
639 return TTS_ERROR_INVALID_PARAMETER;
644 dbus_error_init(&err);
646 msg = __tts_dbus_make_message(uid, TTS_METHOD_SET_PRIVATE_DATA);
649 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts set private data : Fail to make message");
650 return TTS_ERROR_OPERATION_FAILED;
652 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts set private data : uid(%d)", uid);
655 if (true != dbus_message_append_args(msg,
656 DBUS_TYPE_INT32, &uid,
657 DBUS_TYPE_STRING, &key,
658 DBUS_TYPE_STRING, &data,
659 DBUS_TYPE_INVALID)) {
660 dbus_message_unref(msg);
661 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
663 return TTS_ERROR_OPERATION_FAILED;
666 DBusMessage* result_msg;
667 int result = TTS_ERROR_OPERATION_FAILED;
669 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
670 dbus_message_unref(msg);
671 if (dbus_error_is_set(&err)) {
672 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
673 dbus_error_free(&err);
676 if (NULL != result_msg) {
677 dbus_message_get_args(result_msg, &err,
678 DBUS_TYPE_INT32, &result,
681 if (dbus_error_is_set(&err)) {
682 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts set private data : Get arguments error (%s)", err.message);
683 dbus_error_free(&err);
684 result = TTS_ERROR_OPERATION_FAILED;
686 dbus_message_unref(result_msg);
689 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts set private data : result(%d)", result);
691 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts set private data : result(%d)", result);
694 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
695 tts_dbus_reconnect();
696 result = TTS_ERROR_TIMED_OUT;
702 int tts_dbus_request_get_private_data(int uid, const char* key, char** data)
704 if (NULL == key || NULL == data) {
705 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
706 return TTS_ERROR_INVALID_PARAMETER;
711 dbus_error_init(&err);
713 msg = __tts_dbus_make_message(uid, TTS_METHOD_GET_PRIVATE_DATA);
716 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts get private data : Fail to make message");
717 return TTS_ERROR_OPERATION_FAILED;
719 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts get private data : uid(%d)", uid);
722 if (true != dbus_message_append_args(msg,
723 DBUS_TYPE_INT32, &uid,
724 DBUS_TYPE_STRING, &key,
725 DBUS_TYPE_INVALID)) {
726 dbus_message_unref(msg);
727 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
729 return TTS_ERROR_OPERATION_FAILED;
732 DBusMessage* result_msg;
733 int result = TTS_ERROR_OPERATION_FAILED;
735 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
736 dbus_message_unref(msg);
737 if (dbus_error_is_set(&err)) {
738 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
739 dbus_error_free(&err);
743 if (NULL != result_msg) {
744 dbus_message_get_args(result_msg, &err,
745 DBUS_TYPE_INT32, &result,
746 DBUS_TYPE_STRING, &temp,
749 if (dbus_error_is_set(&err)) {
750 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts get private data : Get arguments error (%s)", err.message);
751 dbus_error_free(&err);
752 result = TTS_ERROR_OPERATION_FAILED;
754 dbus_message_unref(result_msg);
757 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts get private data : result(%d)", result);
759 *data = strdup(temp);
762 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts get private data : result(%d)", result);
765 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
766 tts_dbus_reconnect();
767 result = TTS_ERROR_TIMED_OUT;
773 int tts_dbus_request_play(int uid, const char* credential)
777 dbus_error_init(&err);
779 msg = __tts_dbus_make_message(uid, TTS_METHOD_PLAY);
782 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts play : Fail to make message");
783 return TTS_ERROR_OPERATION_FAILED;
785 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts play : uid(%d)", uid);
789 if (NULL == credential) {
790 temp = strdup("NULL");
792 temp = strdup(credential);
795 if (true != dbus_message_append_args(msg,
796 DBUS_TYPE_INT32, &uid,
797 DBUS_TYPE_STRING, &temp,
798 DBUS_TYPE_INVALID)) {
799 dbus_message_unref(msg);
800 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
806 return TTS_ERROR_OPERATION_FAILED;
809 DBusMessage* result_msg;
810 int result = TTS_ERROR_OPERATION_FAILED;
812 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
813 dbus_message_unref(msg);
814 if (dbus_error_is_set(&err)) {
815 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
816 dbus_error_free(&err);
819 if (NULL != result_msg) {
820 dbus_message_get_args(result_msg, &err,
821 DBUS_TYPE_INT32, &result,
824 if (dbus_error_is_set(&err)) {
825 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play : Get arguments error (%s)", err.message);
826 dbus_error_free(&err);
827 result = TTS_ERROR_OPERATION_FAILED;
829 dbus_message_unref(result_msg);
832 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts play : result(%d)", result);
834 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play : result(%d)", result);
837 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
838 tts_dbus_reconnect();
839 result = TTS_ERROR_TIMED_OUT;
849 int tts_dbus_request_stop(int uid)
853 dbus_error_init(&err);
855 msg = __tts_dbus_make_message(uid, TTS_METHOD_STOP);
858 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts stop : Fail to make message");
859 return TTS_ERROR_OPERATION_FAILED;
861 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts stop : uid(%d)", uid);
864 DBusMessage* result_msg;
865 int result = TTS_ERROR_OPERATION_FAILED;
867 if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
868 dbus_message_unref(msg);
869 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
871 return TTS_ERROR_OPERATION_FAILED;
874 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
875 dbus_message_unref(msg);
876 if (dbus_error_is_set(&err)) {
877 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
878 dbus_error_free(&err);
881 if (NULL != result_msg) {
882 dbus_message_get_args(result_msg, &err,
883 DBUS_TYPE_INT32, &result,
886 if (dbus_error_is_set(&err)) {
887 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop : Get arguments error (%s)", err.message);
888 dbus_error_free(&err);
889 result = TTS_ERROR_OPERATION_FAILED;
891 dbus_message_unref(result_msg);
894 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts stop : result(%d)", result);
896 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop : result(%d)", result);
899 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
900 tts_dbus_reconnect();
901 result = TTS_ERROR_TIMED_OUT;
907 int tts_dbus_request_pause(int uid)
911 dbus_error_init(&err);
913 msg = __tts_dbus_make_message(uid, TTS_METHOD_PAUSE);
916 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts pause : Fail to make message");
917 return TTS_ERROR_OPERATION_FAILED;
919 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts pause : uid(%d)", uid);
922 DBusMessage* result_msg;
923 int result = TTS_ERROR_OPERATION_FAILED;
925 if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
926 dbus_message_unref(msg);
927 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
929 return TTS_ERROR_OPERATION_FAILED;
932 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
933 dbus_message_unref(msg);
934 if (dbus_error_is_set(&err)) {
935 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
936 dbus_error_free(&err);
939 if (NULL != result_msg) {
940 dbus_message_get_args(result_msg, &err,
941 DBUS_TYPE_INT32, &result,
944 if (dbus_error_is_set(&err)) {
945 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts pause : Get arguments error (%s)", err.message);
946 dbus_error_free(&err);
947 result = TTS_ERROR_OPERATION_FAILED;
949 dbus_message_unref(result_msg);
952 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts pause : result(%d)", result);
954 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts pause : result(%d)", result);
957 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
958 tts_dbus_reconnect();
959 result = TTS_ERROR_TIMED_OUT;
966 int tts_dbus_request_play_pcm(int uid)
970 dbus_error_init(&err);
972 msg = __tts_dbus_make_message(uid, TTS_METHOD_PLAY_PCM);
975 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts play pcm : Fail to make message");
976 return TTS_ERROR_OPERATION_FAILED;
978 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts play pcm : uid(%d)", uid);
981 if (true != dbus_message_append_args(msg,
982 DBUS_TYPE_INT32, &uid,
983 DBUS_TYPE_INVALID)) {
984 dbus_message_unref(msg);
985 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
986 return TTS_ERROR_OPERATION_FAILED;
989 DBusMessage* result_msg;
990 int result = TTS_ERROR_OPERATION_FAILED;
992 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
993 dbus_message_unref(msg);
994 if (dbus_error_is_set(&err)) {
995 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
996 dbus_error_free(&err);
999 if (NULL != result_msg) {
1000 dbus_message_get_args(result_msg, &err,
1001 DBUS_TYPE_INT32, &result,
1004 if (dbus_error_is_set(&err)) {
1005 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play pcm : Get arguments error (%s)", err.message);
1006 dbus_error_free(&err);
1007 result = TTS_ERROR_OPERATION_FAILED;
1009 dbus_message_unref(result_msg);
1012 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts play pcm : result(%d)", result);
1014 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play pcm : result(%d)", result);
1017 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
1018 tts_dbus_reconnect();
1019 result = TTS_ERROR_TIMED_OUT;
1025 int tts_dbus_request_stop_pcm(int uid)
1029 dbus_error_init(&err);
1031 msg = __tts_dbus_make_message(uid, TTS_METHOD_STOP_PCM);
1034 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts stop pcm : Fail to make message");
1035 return TTS_ERROR_OPERATION_FAILED;
1037 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts stop pcm : uid(%d)", uid);
1040 if (true != dbus_message_append_args(msg,
1041 DBUS_TYPE_INT32, &uid,
1042 DBUS_TYPE_INVALID)) {
1043 dbus_message_unref(msg);
1044 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
1045 return TTS_ERROR_OPERATION_FAILED;
1048 DBusMessage* result_msg;
1049 int result = TTS_ERROR_OPERATION_FAILED;
1051 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
1052 dbus_message_unref(msg);
1053 if (dbus_error_is_set(&err)) {
1054 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
1055 dbus_error_free(&err);
1058 if (NULL != result_msg) {
1059 dbus_message_get_args(result_msg, &err,
1060 DBUS_TYPE_INT32, &result,
1063 if (dbus_error_is_set(&err)) {
1064 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop pcm : Get arguments error (%s)", err.message);
1065 dbus_error_free(&err);
1066 result = TTS_ERROR_OPERATION_FAILED;
1068 dbus_message_unref(result_msg);
1071 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts stop pcm : result(%d)", result);
1073 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop pcm : result(%d)", result);
1076 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
1077 tts_dbus_reconnect();
1078 result = TTS_ERROR_TIMED_OUT;
1084 int tts_dbus_request_add_pcm(int uid, int event, const char* data, int data_size, int audio_type, int rate)
1088 dbus_error_init(&err);
1090 msg = __tts_dbus_make_message(uid, TTS_METHOD_ADD_PCM);
1093 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts add pcm : Fail to make message");
1094 return TTS_ERROR_OPERATION_FAILED;
1096 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts add pcm : uid(%d)", uid);
1099 if (true != dbus_message_append_args(msg,
1100 DBUS_TYPE_INT32, &uid,
1101 DBUS_TYPE_INT32, &event,
1102 DBUS_TYPE_INT32, &audio_type,
1103 DBUS_TYPE_INT32, &rate,
1104 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
1106 DBUS_TYPE_INVALID)) {
1107 dbus_message_unref(msg);
1108 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
1109 return TTS_ERROR_OPERATION_FAILED;
1112 DBusMessage* result_msg;
1113 int result = TTS_ERROR_OPERATION_FAILED;
1115 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
1116 dbus_message_unref(msg);
1117 if (dbus_error_is_set(&err)) {
1118 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
1119 dbus_error_free(&err);
1122 if (NULL != result_msg) {
1123 dbus_message_get_args(result_msg, &err,
1124 DBUS_TYPE_INT32, &result,
1127 if (dbus_error_is_set(&err)) {
1128 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts add pcm : Get arguments error (%s)", err.message);
1129 dbus_error_free(&err);
1130 result = TTS_ERROR_OPERATION_FAILED;
1132 dbus_message_unref(result_msg);
1135 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts add pcm : result(%d)", result);
1137 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts add pcm : result(%d)", result);
1140 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
1141 tts_dbus_reconnect();
1142 result = TTS_ERROR_TIMED_OUT;