Add a logic to check tts engine is installed and launched

Change-Id: Ic7e6adb8e3fc170b793317627d3403fb6a315f47
Signed-off-by: sooyeon.kim <sooyeon.kim@samsung.com>

diff --git a/client/tts.c b/client/tts.c
index e8428a0..06c89f0 100644 (file)
--- a/client/tts.c
+++ b/client/tts.c
@@ -52,6 +52,7 @@ static int g_retry_cnt = 0;
 /* for checking engine update */
 static pkgmgr_client* g_pkgmgr = NULL;
 static char* g_engine_name = NULL;
+static char g_engine_appid[256];
 static int g_engine_update_status = 0;
 static pthread_mutex_t g_pkgmgr_mutex = PTHREAD_MUTEX_INITIALIZER;
 
@@ -338,6 +339,65 @@ static void __pkgmgr_thread(void* data)
        return ;
 }
 
+static void __tts_get_engine_appid(tts_client_s* client, char* engine_name, char** engine_appid)
+{
+       char temp[256];
+       memset(temp, '\0', 256);
+
+       if (NULL == client) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
+               return;
+       }
+
+       if (TTS_MODE_DEFAULT == client->mode) {
+               snprintf(temp, 256, "%s", engine_name);
+       } else if (TTS_MODE_NOTIFICATION == client->mode) {
+               snprintf(temp, 256, "%s-noti", engine_name);
+       } else if (TTS_MODE_SCREEN_READER == client->mode) {
+               snprintf(temp, 256, "%s-sr", engine_name);
+       } else if (TTS_MODE_INTERRUPT == client->mode) {
+               snprintf(temp, 256, "%s-interrupt", engine_name);
+       }
+       *engine_appid = strdup(temp);
+       return;
+}
+
+static void __tts_config_engine_changed_cb(keynode_t* key, void* data)
+{
+       SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts engine vconfkey is changed");
+
+       tts_h temp = (tts_h)data;
+
+       g_engine_name = vconf_get_str(TTS_ENGINE_DB_DEFAULT);
+       if (NULL == g_engine_name) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get engine name");
+               return;
+       } else {
+               SLOG(LOG_ERROR, TAG_TTSC, "[INFO] Engine name(%s)", g_engine_name);
+       }
+
+       memset(g_engine_appid, '\0', 256);
+
+       tts_client_s* client = tts_client_get(temp);
+       if (NULL == client) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
+               snprintf(g_engine_appid, 256, "%s", g_engine_name);
+               SLOG(LOG_INFO, TAG_TTSC, "[INFO] default tts engine name(%s), appid(%s)", g_engine_name, g_engine_appid);
+               return ;
+       }
+
+       char* engine_appid = NULL;
+       __tts_get_engine_appid(client, g_engine_name, &engine_appid);
+       if (engine_appid) {
+               snprintf(g_engine_appid, 256, "%s", engine_appid);
+               free(engine_appid);
+       }
+
+       SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts engine name(%s), appid(%s)", g_engine_name, g_engine_appid);
+
+       return;
+}
+
 int tts_create(tts_h* tts)
 {
        if (0 != __tts_get_feature_enabled()) {
@@ -398,6 +458,16 @@ int tts_create(tts_h* tts)
                SLOG(LOG_ERROR, TAG_TTSC, "[INFO] Engine name(%s)", g_engine_name);
        }
 
+       memset(g_engine_appid, '\0', 256);
+       if (NULL != g_engine_name) {
+               snprintf(g_engine_appid, 256, "%s", g_engine_name);
+
+               SLOG(LOG_ERROR, TAG_TTSC, "[INFO] engine appid(%s)", g_engine_appid);
+       }
+
+       /* Register vconfkey callback to detect engine change */
+       vconf_notify_key_changed(TTS_ENGINE_DB_DEFAULT, __tts_config_engine_changed_cb, client->tts);
+
        SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
        SLOG(LOG_DEBUG, TAG_TTSC, " ");
 
@@ -433,6 +503,9 @@ int tts_destroy(tts_h tts)
                return TTS_ERROR_OPERATION_FAILED;
        }
 
+       /* Unregister vconfkey callback */
+       vconf_ignore_key_changed(TTS_ENGINE_DB_DEFAULT, __tts_config_engine_changed_cb);
+
        tts_config_mgr_finalize(client->uid);
 
        if (client->hello_timer) {
@@ -587,6 +660,19 @@ int tts_set_mode(tts_h tts, tts_mode_e mode)
                tts_config_unset_screen_reader_callback(client->uid);
        }
 
+       memset(g_engine_appid, '\0', 256);
+       if (TTS_MODE_DEFAULT == mode) {
+               snprintf(g_engine_appid, 256, "%s", g_engine_name);
+       } else if (TTS_MODE_NOTIFICATION == mode) {
+               snprintf(g_engine_appid, 256, "%s-noti", g_engine_name);
+       } else if (TTS_MODE_SCREEN_READER == mode) {
+               snprintf(g_engine_appid, 256, "%s-sr", g_engine_name);
+       } else if (TTS_MODE_INTERRUPT == mode) {
+               snprintf(g_engine_appid, 256, "%s-interrupt", g_engine_name);
+       }
+
+       SLOG(LOG_INFO, tts_tag(), "[INFO] engine appid(%s)", g_engine_appid);
+
        SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
        return TTS_ERROR_NONE;
@@ -903,6 +989,48 @@ int __tts_cb_hello(int uid, int ret, int credential_needed)
        return TTS_ERROR_NONE;
 }
 
+static bool __is_engine_installed(const char* appid)
+{
+       app_info_h app_info = NULL;
+       int ret = app_manager_get_app_info(appid, &app_info);
+       if (APP_MANAGER_ERROR_NONE != ret || NULL == app_info) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] There is no tts engine (%s). ret(%d)", appid, ret);
+               return false;
+       } else {
+               SLOG(LOG_INFO, TAG_TTSC, "[INFO] There is tts engine (%s)", appid);
+       }
+
+       ret = app_info_destroy(app_info);
+       if (APP_MANAGER_ERROR_NONE != ret)
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to destroy app_info. ret(%d)", ret);
+
+       return true;
+}
+
+static bool __is_engine_launched(const char* appid)
+{
+       int ret = -1;
+       bool is_installed = false;
+       bool is_running = false;
+       is_installed = __is_engine_installed(appid);
+
+       if (false == is_installed) {
+               SLOG(LOG_WARN, TAG_TTSC, "[WARNING] tts engine(%s) is not installed", appid);
+               return false;
+       } else {
+               ret = app_manager_is_running(appid, &is_running);
+               if (APP_MANAGER_ERROR_NONE != ret) {
+                       SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to check whether appid(%s) is running or not. ret(%d)", appid, ret);
+                       SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts engine is installed(%d)", is_installed);
+                       return false;
+               } else {
+                       SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts engine is%s running. is_installed(%d)", (is_running) ? "" : " not", is_installed);
+               }
+
+               return is_running;
+       }
+}
+
 static Eina_Bool __send_hello(void *data)
 {
        tts_h tts = (tts_h)data;
@@ -945,6 +1073,10 @@ static Eina_Bool __send_hello(void *data)
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Stop to send hello, retry count reaches the limit");
                g_retry_cnt = 0;
                client->hello_timer = NULL;
+
+               bool is_launched = __is_engine_launched(g_engine_appid);
+               SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts engine is launched(%d)", is_launched);
+
                return EINA_FALSE;
        }