client/tts_client.c

   1 /*
   2 *  Copyright (c) 2011-2014 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.
  12 */
  13
  14
  15 #include "tts_client.h"
  16
  17 /* Max number of handle */
  18 static const int g_max_handle = 999;
  19 /* allocated handle */
  20 static int g_allocated_handle = 0;
  21 /* client list */
  22 static GList *g_client_list = NULL;
  23
  24 /* private functions */
  25 static int __client_generate_uid(int pid)
  26 {
  27         g_allocated_handle++;
  28
  29         if (g_allocated_handle > g_max_handle) {
  30                 g_allocated_handle = 1;
  31         }
  32
  33         /* generate uid, handle number should be smaller than 1000 */
  34         return pid * 1000 + g_allocated_handle;
  35 }
  36
  37 int tts_client_new(tts_h* tts)
  38 {
  39         tts_client_s* client = NULL;
  40         client = (tts_client_s*)calloc(1, sizeof(tts_client_s));
  41         if (NULL == client) {
  42                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
  43                 return TTS_ERROR_OUT_OF_MEMORY;
  44         }
  45         tts_h temp = (tts_h)calloc(1, sizeof(struct tts_s));
  46         if (NULL == temp) {
  47                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
  48                 free(client);
  49                 return TTS_ERROR_OUT_OF_MEMORY;
  50         }
  51         temp->handle = __client_generate_uid(getpid());
  52
  53         /* initialize client data */
  54         client->tts = temp;
  55         client->pid = getpid();
  56         client->uid = temp->handle;
  57         client->current_utt_id = 0;
  58
  59         client->state_changed_cb = NULL;
  60         client->state_changed_user_data = NULL;
  61
  62         client->utt_started_cb = NULL;
  63         client->utt_started_user_data = NULL;
  64         client->utt_completeted_cb = NULL;
  65         client->utt_completed_user_data = NULL;
  66
  67         client->error_cb = NULL;
  68         client->error_user_data = NULL;
  69         client->default_voice_changed_cb = NULL;
  70         client->default_voice_changed_user_data = NULL;
  71         client->supported_voice_cb = NULL;
  72         client->supported_voice_user_data = NULL;
  73
  74         client->mode = TTS_MODE_DEFAULT;
  75         client->before_state = TTS_STATE_CREATED;
  76         client->current_state = TTS_STATE_CREATED;
  77
  78         client->cb_ref_count = 0;
  79
  80         g_client_list = g_list_append(g_client_list, client);
  81
  82         *tts = temp;
  83
  84         SLOG(LOG_DEBUG, TAG_TTSC, "[Success] Create client object : uid(%d)", client->uid);
  85
  86         return TTS_ERROR_NONE;
  87 }
  88
  89 int tts_client_destroy(tts_h tts)
  90 {
  91         if (tts == NULL) {
  92                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
  93                 return TTS_ERROR_INVALID_PARAMETER;
  94         }
  95
  96         GList *iter = NULL;
  97         tts_client_s *data = NULL;
  98
  99         /* if list have item */
 100         if (g_list_length(g_client_list) > 0) {
 101                 /* Get a first item */
 102                 iter = g_list_first(g_client_list);
 103
 104                 while (NULL != iter) {
 105                         data = iter->data;
 106                         if (tts->handle == data->tts->handle) {
 107                                 g_client_list = g_list_remove_link(g_client_list, iter);
 108
 109                                 while (0 != data->cb_ref_count) {
 110                                         /* wait for release callback function */
 111                                 }
 112                                 free(data);
 113                                 free(tts);
 114
 115                                 return TTS_ERROR_NONE;
 116                         }
 117
 118                         /* Next item */
 119                         iter = g_list_next(iter);
 120                 }
 121         }
 122         SLOG(LOG_ERROR, TAG_TTSC, "Fail to destroy client : handle is not valid");
 123
 124         return TTS_ERROR_INVALID_PARAMETER;
 125 }
 126
 127 tts_client_s* tts_client_get(tts_h tts)
 128 {
 129         if (tts == NULL) {
 130                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 131                 return NULL;
 132         }
 133
 134         GList *iter = NULL;
 135         tts_client_s *data = NULL;
 136
 137         if (g_list_length(g_client_list) > 0) {
 138                 /* Get a first item */
 139                 iter = g_list_first(g_client_list);
 140
 141                 while (NULL != iter) {
 142                         data = iter->data;
 143
 144                         if (tts->handle == data->tts->handle)
 145                                 return data;
 146
 147                         /* Next item */
 148                         iter = g_list_next(iter);
 149                 }
 150         }
 151
 152         SLOG(LOG_ERROR, TAG_TTSC, "handle is not valid");
 153
 154         return NULL;
 155 }
 156
 157 tts_client_s* tts_client_get_by_uid(const int uid)
 158 {
 159         if (uid < 0) {
 160                 SLOG(LOG_ERROR, TAG_TTSC, "out of range : handle");
 161                 return NULL;
 162         }
 163
 164         GList *iter = NULL;
 165         tts_client_s *data = NULL;
 166
 167         if (g_list_length(g_client_list) > 0) {
 168                 /* Get a first item */
 169                 iter = g_list_first(g_client_list);
 170
 171                 while (NULL != iter) {
 172                         data = iter->data;
 173                         if (uid == data->uid) {
 174                                 return data;
 175                         }
 176
 177                         /* Next item */
 178                         iter = g_list_next(iter);
 179                 }
 180         }
 181
 182         SLOG(LOG_WARN, TAG_TTSC, "uid is not valid");
 183
 184         return NULL;
 185 }
 186
 187 int tts_client_get_size()
 188 {
 189         return g_list_length(g_client_list);
 190 }
 191
 192 int tts_client_use_callback(tts_client_s* client)
 193 {
 194         client->cb_ref_count++;
 195         return 0;
 196 }
 197
 198 int tts_client_not_use_callback(tts_client_s* client)
 199 {
 200         client->cb_ref_count--;
 201         return 0;
 202 }
 203
 204 int tts_client_get_use_callback(tts_client_s* client)
 205 {
 206         return client->cb_ref_count;
 207 }
 208
 209 int tts_client_get_connected_client_count()
 210 {
 211         GList *iter = NULL;
 212         tts_client_s *data = NULL;
 213         int number = 0;
 214
 215         if (g_list_length(g_client_list) > 0) {
 216                 /* Get a first item */
 217                 iter = g_list_first(g_client_list);
 218
 219                 while (NULL != iter) {
 220                         data = iter->data;
 221                         if (0 < data->current_state) {
 222                                 number++;
 223                         }
 224
 225                         /* Next item */
 226                         iter = g_list_next(iter);
 227                 }
 228         }
 229         return number;
 230 }
 231
 232 int tts_client_get_mode_client_count(tts_mode_e mode)
 233 {
 234         GList *iter = NULL;
 235         tts_client_s *data = NULL;
 236         int number = 0;
 237
 238         if (g_list_length(g_client_list) > 0) {
 239                 /* Get a first item */
 240                 iter = g_list_first(g_client_list);
 241
 242                 while (NULL != iter) {
 243                         data = iter->data;
 244                         if (0 < data->current_state && data->mode == mode) {
 245                                 number++;
 246                         }
 247
 248                         /* Next item */
 249                         iter = g_list_next(iter);
 250                 }
 251         }
 252         return number;
 253 }
 254
 255 GList* tts_client_get_client_list()
 256 {
 257         return g_client_list;
 258 }