Make structure for saving tidl information

Change-Id: I7942601167e84d18de3ca287ed9d142141fbf824
Signed-off-by: Suyeon Hwang <stom.hwang@samsung.com>

diff --git a/client/tts_client.c b/client/tts_client.c
index 652f8d5..841ee52 100644 (file)
--- a/client/tts_client.c
+++ b/client/tts_client.c
@@ -104,8 +104,6 @@ int tts_client_new(tts_h* tts)
        }
 
        temp->handle = __client_generate_uid(getpid());
-       temp->connected = false;
-       temp->rpc_h = NULL;
 
        /* initialize client data */
        client->tts = temp;

diff --git a/client/tts_main.h b/client/tts_main.h
index 24ec64b..9f5068a 100644 (file)
--- a/client/tts_main.h
+++ b/client/tts_main.h
@@ -1,5 +1,5 @@
 /*
-*  Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved 
+*  Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
@@ -25,7 +25,6 @@
 #include <dlog.h>
 
 #include "tts_defs.h"
-#include "tts_proxy.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -36,8 +35,6 @@ extern "C" {
 */
 struct tts_s {
        int handle;
-       rpc_port_proxy_tts_h rpc_h;
-       bool connected;
 };
 
 #ifdef __cplusplus

diff --git a/client/tts_tidl.c b/client/tts_tidl.c
index 8b97b9c..fbfb3a2 100644 (file)
--- a/client/tts_tidl.c
+++ b/client/tts_tidl.c
@@ -13,12 +13,44 @@
 #include <rpc-port.h>
 #include "tts_main.h"
 #include "tts_tidl.h"
+#include "tts_proxy.h"
 #include "tts_internal.h"
 #include "tts_client.h"
 #include "tts_core.h"
 
 #define MAXSLEEP 128
 
+typedef struct {
+       int uid;
+       bool connected;
+       rpc_port_proxy_tts_h rpc_h;
+} tts_tidl_info_s;
+
+static GList* g_tidl_infos = NULL;
+
+static tts_tidl_info_s* __get_tidl_info_s(int uid)
+{
+       GList* iter = NULL;
+       tts_tidl_info_s* info = NULL;
+
+       if (g_list_length(g_tidl_infos) > 0) {
+               /* Get a first item */
+               iter = g_list_first(g_tidl_infos);
+
+               while (NULL != iter) {
+                       info = iter->data;
+
+                       if (info->uid == uid) {
+                               return info;
+                       }
+
+                       /* Next item */
+                       iter = g_list_next(iter);
+               }
+       }
+
+       return NULL;
+}
 
 static int __tts_cb_set_state(int uid, int state)
 {
@@ -151,14 +183,14 @@ static void __on_connected(rpc_port_proxy_tts_h h, void *user_data)
                return;
        }
 
-       tts_h tts = tts_client_get_handle(client);
-       if (NULL == tts) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tts handle");
+       tts_tidl_info_s* info = __get_tidl_info_s(uid);
+       if (NULL == info) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
                return;
        }
 
-       tts->connected = true;
-       if (0 != rpc_port_proxy_tts_invoke_set_mode(tts->rpc_h, tts_client_get_mode(client))) {
+       info->connected = true;
+       if (0 != rpc_port_proxy_tts_invoke_set_mode(info->rpc_h, tts_client_get_mode(client))) {
                SLOG(LOG_ERROR, TAG_TTSC, "Failed to set mode");
                return;
        }
@@ -176,13 +208,13 @@ static void __on_disconnected(rpc_port_proxy_tts_h h, void *user_data)
                return;
        }
 
-       tts_h tts = tts_client_get_handle(client);
-       if (NULL == tts) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tts handle");
+       tts_tidl_info_s* info = __get_tidl_info_s(uid);
+       if (NULL == info) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
                return;
        }
 
-       tts->connected = false;
+       info->connected = false;
        if (tts_client_is_listening_started(uid)) {
                tts_core_handle_service_reset();
                SLOG(LOG_DEBUG, TAG_TTSC, "Disconnected from server");
@@ -222,10 +254,10 @@ int tts_tidl_open_connection(int uid)
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       tts_h tts = tts_client_get_handle(client);
-       if (NULL == tts) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tts handle");
-               return TTS_ERROR_INVALID_PARAMETER;
+       tts_tidl_info_s* info = (tts_tidl_info_s*)calloc(1, sizeof(tts_tidl_info_s));
+       if (NULL == info) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create tidl_info_s");
+               return TTS_ERROR_OUT_OF_MEMORY;
        }
 
        engine_name = vconf_get_str(TTS_ENGINE_DB_DEFAULT);
@@ -250,25 +282,28 @@ int tts_tidl_open_connection(int uid)
                }
                client->reason = 0; // default value
        }
+       free(engine_name);
 
        intptr_t ptr_uid = uid;
-       if (0 != rpc_port_proxy_tts_create(engine_mode, &rpc_callback, (void*)ptr_uid, &tts->rpc_h)) {
-               free(engine_name);
+       if (0 != rpc_port_proxy_tts_create(engine_mode, &rpc_callback, (void*)ptr_uid, &info->rpc_h)) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create proxy");
+               free(info);
                return TTS_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_tts_connect(tts->rpc_h)) {
-               rpc_port_proxy_tts_destroy(tts->rpc_h);
-               tts->rpc_h = NULL;
-               free(engine_name);
+       if (0 != rpc_port_proxy_tts_connect(info->rpc_h)) {
+               rpc_port_proxy_tts_destroy(info->rpc_h);
+               info->rpc_h = NULL;
+               free(info);
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to connect the service");
                return TTS_ERROR_OPERATION_FAILED;
        }
-       SLOG(LOG_ERROR, TAG_TTSC, "[INFO] tts_h(%p) rpc_h(%p) engine(%s)", tts, tts->rpc_h, engine_mode);
-       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
-       free(engine_name);
 
+       info->uid = uid;
+       g_tidl_infos = g_list_append(g_tidl_infos, info);
+
+       SLOG(LOG_ERROR, TAG_TTSC, "[INFO] uid(%d) rpc_h(%p) engine(%s)", uid, info->rpc_h, engine_mode);
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
        return TTS_ERROR_NONE;
 }
 
@@ -282,19 +317,21 @@ int tts_tidl_close_connection(int uid)
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       tts_h tts = tts_client_get_handle(client);
-       if (NULL == tts) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tts handle");
+       tts_tidl_info_s* info = __get_tidl_info_s(uid);
+       if (NULL == info) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       if (0 != rpc_port_proxy_tts_destroy(tts->rpc_h)) {
+       if (0 != rpc_port_proxy_tts_destroy(info->rpc_h)) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to disconnect");
                return TTS_ERROR_OPERATION_FAILED;
        }
+       info->rpc_h = NULL;
+
+       g_tidl_infos = g_list_remove(g_tidl_infos, info);
+       free(info);
 
-       tts->rpc_h = NULL;
-       tts->connected = false;
        return TTS_ERROR_NONE;
 }
 
@@ -320,13 +357,13 @@ int tts_tidl_request_hello(int uid)
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       tts_h tts = tts_client_get_handle(client);
-       if (NULL == tts) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tts handle");
+       tts_tidl_info_s* info = __get_tidl_info_s(uid);
+       if (NULL == info) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       if (!tts->connected) {
+       if (!info->connected) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
                return TTS_ERROR_OPERATION_FAILED;
        }
@@ -334,7 +371,7 @@ int tts_tidl_request_hello(int uid)
        SLOG(LOG_DEBUG, TAG_TTSC, ">>>>> TTS Hello");
        /* register callback - needed to create new client before adding callback */
        rpc_port_tts_notify_cb_h cb = rpc_port_tts_notify_cb_create(__notify_cb, false, NULL);
-       if (0 != rpc_port_proxy_tts_invoke_register_cb(tts->rpc_h, client->pid, uid, cb)) {
+       if (0 != rpc_port_proxy_tts_invoke_register_cb(info->rpc_h, client->pid, uid, cb)) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Failed to invoke register");
                return TTS_ERROR_OPERATION_FAILED;
        }
@@ -359,20 +396,20 @@ int tts_tidl_request_initialize(int uid, bool* credential_needed)
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       tts_h tts = tts_client_get_handle(client);
-       if (NULL == tts) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tts handle");
+       tts_tidl_info_s* info = __get_tidl_info_s(uid);
+       if (NULL == info) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
        bool temp;
 
-       if (!tts->connected) {
+       if (!info->connected) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
                return TTS_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_tts_invoke_initialize(tts->rpc_h, client->pid, uid, &temp)) {
+       if (0 != rpc_port_proxy_tts_invoke_initialize(info->rpc_h, client->pid, uid, &temp)) {
                SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts initialize : Fail to invoke message");
                return TTS_ERROR_OPERATION_FAILED;
        }
@@ -394,18 +431,18 @@ int tts_tidl_request_finalize(int uid)
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       tts_h tts = tts_client_get_handle(client);
-       if (NULL == tts) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tts handle");
+       tts_tidl_info_s* info = __get_tidl_info_s(uid);
+       if (NULL == info) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       if (!tts->connected) {
+       if (!info->connected) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
                return TTS_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_tts_invoke_finalize(tts->rpc_h, uid)) {
+       if (0 != rpc_port_proxy_tts_invoke_finalize(info->rpc_h, uid)) {
                SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts initialize : Fail to invoke message");
                return TTS_ERROR_OPERATION_FAILED;
        }
@@ -424,9 +461,9 @@ int tts_tidl_request_add_text(int uid, const char* text, const char* lang, int v
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       tts_h tts = tts_client_get_handle(client);
-       if (NULL == tts) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tts handle");
+       tts_tidl_info_s* info = __get_tidl_info_s(uid);
+       if (NULL == info) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
@@ -435,12 +472,12 @@ int tts_tidl_request_add_text(int uid, const char* text, const char* lang, int v
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       if (!tts->connected) {
+       if (!info->connected) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
                return TTS_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_tts_invoke_add_text(tts->rpc_h, uid, text, lang, vctype, speed, uttid, credential)) {
+       if (0 != rpc_port_proxy_tts_invoke_add_text(info->rpc_h, uid, text, lang, vctype, speed, uttid, credential)) {
                SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request add text : Fail to invoke message");
                return TTS_ERROR_OPERATION_FAILED;
        }
@@ -458,9 +495,9 @@ int tts_tidl_request_set_private_data(int uid, const char* key, const char* data
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       tts_h tts = tts_client_get_handle(client);
-       if (NULL == tts) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tts handle");
+       tts_tidl_info_s* info = __get_tidl_info_s(uid);
+       if (NULL == info) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
@@ -469,12 +506,12 @@ int tts_tidl_request_set_private_data(int uid, const char* key, const char* data
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       if (!tts->connected) {
+       if (!info->connected) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
                return TTS_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_tts_invoke_set_private(tts->rpc_h, uid, key, data)) {
+       if (0 != rpc_port_proxy_tts_invoke_set_private(info->rpc_h, uid, key, data)) {
                SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request set private data : Fail to invoke message");
                return TTS_ERROR_OPERATION_FAILED;
        }
@@ -492,9 +529,9 @@ int tts_tidl_request_get_private_data(int uid, const char* key, char** data)
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       tts_h tts = tts_client_get_handle(client);
-       if (NULL == tts) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tts handle");
+       tts_tidl_info_s* info = __get_tidl_info_s(uid);
+       if (NULL == info) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
@@ -505,12 +542,12 @@ int tts_tidl_request_get_private_data(int uid, const char* key, char** data)
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       if (!tts->connected) {
+       if (!info->connected) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
                return TTS_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_tts_invoke_get_private(tts->rpc_h, uid, key, &tmp)) {
+       if (0 != rpc_port_proxy_tts_invoke_get_private(info->rpc_h, uid, key, &tmp)) {
                SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request get private data : Fail to invoke message");
                return TTS_ERROR_OPERATION_FAILED;
        }
@@ -531,18 +568,18 @@ int tts_tidl_request_play(int uid, const char* credential)
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       tts_h tts = tts_client_get_handle(client);
-       if (NULL == tts) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tts handle");
+       tts_tidl_info_s* info = __get_tidl_info_s(uid);
+       if (NULL == info) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       if (!tts->connected) {
+       if (!info->connected) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
                return TTS_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_tts_invoke_play(tts->rpc_h, uid, credential)) {
+       if (0 != rpc_port_proxy_tts_invoke_play(info->rpc_h, uid, credential)) {
                SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request play : Fail to invoke message");
                return TTS_ERROR_OPERATION_FAILED;
        }
@@ -562,18 +599,18 @@ int tts_tidl_request_stop(int uid)
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       tts_h tts = tts_client_get_handle(client);
-       if (NULL == tts) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tts handle");
+       tts_tidl_info_s* info = __get_tidl_info_s(uid);
+       if (NULL == info) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       if (!tts->connected) {
+       if (!info->connected) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
                return TTS_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_tts_invoke_stop(tts->rpc_h, uid)) {
+       if (0 != rpc_port_proxy_tts_invoke_stop(info->rpc_h, uid)) {
                SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request stop : Fail to invoke message");
                return TTS_ERROR_OPERATION_FAILED;
        }
@@ -592,18 +629,18 @@ int tts_tidl_request_pause(int uid)
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       tts_h tts = tts_client_get_handle(client);
-       if (NULL == tts) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tts handle");
+       tts_tidl_info_s* info = __get_tidl_info_s(uid);
+       if (NULL == info) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       if (!tts->connected) {
+       if (!info->connected) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
                return TTS_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_tts_invoke_pause(tts->rpc_h, uid)) {
+       if (0 != rpc_port_proxy_tts_invoke_pause(info->rpc_h, uid)) {
                SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request pause : Fail to invoke message");
                return TTS_ERROR_OPERATION_FAILED;
        }
@@ -624,18 +661,18 @@ int tts_tidl_request_play_pcm(int uid)
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       tts_h tts = tts_client_get_handle(client);
-       if (NULL == tts) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tts handle");
+       tts_tidl_info_s* info = __get_tidl_info_s(uid);
+       if (NULL == info) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       if (!tts->connected) {
+       if (!info->connected) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
                return TTS_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_tts_invoke_play_pcm(tts->rpc_h, uid)) {
+       if (0 != rpc_port_proxy_tts_invoke_play_pcm(info->rpc_h, uid)) {
                SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request play pcm : Fail to invoke message");
                return TTS_ERROR_OPERATION_FAILED;
        }
@@ -655,18 +692,18 @@ int tts_tidl_request_stop_pcm(int uid)
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       tts_h tts = tts_client_get_handle(client);
-       if (NULL == tts) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tts handle");
+       tts_tidl_info_s* info = __get_tidl_info_s(uid);
+       if (NULL == info) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       if (!tts->connected) {
+       if (!info->connected) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
                return TTS_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_tts_invoke_stop_pcm(tts->rpc_h, uid)) {
+       if (0 != rpc_port_proxy_tts_invoke_stop_pcm(info->rpc_h, uid)) {
                SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request pause pcm : Fail to invoke message");
                return TTS_ERROR_OPERATION_FAILED;
        }
@@ -686,18 +723,18 @@ int tts_tidl_request_add_pcm(int uid, int event, const char* data, int data_size
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       tts_h tts = tts_client_get_handle(client);
-       if (NULL == tts) {
-               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tts handle");
+       tts_tidl_info_s* info = __get_tidl_info_s(uid);
+       if (NULL == info) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       if (!tts->connected) {
+       if (!info->connected) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not Connected");
                return TTS_ERROR_OPERATION_FAILED;
        }
 
-       if (0 != rpc_port_proxy_tts_invoke_add_pcm(tts->rpc_h, uid, event, data, data_size, audio_type, rate)) {
+       if (0 != rpc_port_proxy_tts_invoke_add_pcm(info->rpc_h, uid, event, data, data_size, audio_type, rate)) {
                SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request pause pcm : Fail to invoke message");
                return TTS_ERROR_OPERATION_FAILED;
        }

diff --git a/client/tts_tidl.h b/client/tts_tidl.h
index e20657e..5bc88e8 100644 (file)
--- a/client/tts_tidl.h
+++ b/client/tts_tidl.h
@@ -14,8 +14,6 @@
 #ifndef __TTS_TIDL_H_
 #define __TTS_TIDL_H_
 
-#include "tts_client.h"
-
 #ifdef __cplusplus
 extern "C" {
 #endif