client/stt_client.c

   1 /*
   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.
  12 */
  13
  14
  15 #include "stt_client.h"
  16
  17 #define MUTEX_TIME 3
  18
  19 /* Max number of handle */
  20 static const int g_max_handle = 999;
  21 /* allocated handle */
  22 static int g_allocated_handle = 0;
  23 /* client list */
  24 static GList *g_client_list = NULL;
  25
  26
  27 /* private functions */
  28 static int __client_generate_uid(int pid)
  29 {
  30         g_allocated_handle++;
  31
  32         if (g_allocated_handle > g_max_handle) {
  33                 g_allocated_handle = 1;
  34         }
  35
  36         /* generate uid, handle number should be smaller than 1000 */
  37         return pid * 1000 + g_allocated_handle;
  38 }
  39
  40 int stt_client_new(stt_h* stt)
  41 {
  42         stt_client_s *client = NULL;
  43
  44         client = (stt_client_s*)calloc(1, sizeof(stt_client_s));
  45         if (NULL == client) {
  46                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
  47                 return STT_ERROR_OUT_OF_MEMORY;
  48         }
  49
  50         stt_h temp = (stt_h)calloc(1, sizeof(struct stt_s));
  51         if (NULL == temp) {
  52                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
  53                 free(client);
  54                 return STT_ERROR_OUT_OF_MEMORY;
  55         }
  56         temp->handle = __client_generate_uid(getpid());
  57
  58         /* initialize client data */
  59         client->stt = temp;
  60         client->pid = getpid();
  61         client->uid = temp->handle;
  62
  63         client->recognition_result_cb = NULL;
  64         client->recognition_result_user_data = NULL;
  65         client->state_changed_cb = NULL;
  66         client->state_changed_user_data = NULL;
  67         client->error_cb = NULL;
  68         client->error_user_data = NULL;
  69         client->default_lang_changed_cb = NULL;
  70         client->default_lang_changed_user_data = NULL;
  71         client->speech_status_cb = NULL;
  72         client->speech_status_user_data = NULL;
  73
  74         client->current_engine_id = NULL;
  75         client->credential = NULL;
  76
  77         client->silence_supported = false;
  78         client->silence = STT_OPTION_SILENCE_DETECTION_AUTO;
  79
  80         client->event = 0;
  81         client->data_list = NULL;
  82         client->data_count = 0;
  83         client->msg = NULL;
  84
  85         client->reason = 0;
  86         client->err_msg = NULL;
  87
  88         client->before_state = STT_STATE_CREATED;
  89         client->current_state = STT_STATE_CREATED;
  90
  91         client->internal_state = STT_INTERNAL_STATE_NONE;
  92
  93         client->speech_status = -1;
  94
  95         client->cb_ref_count = 0;
  96
  97         g_client_list = g_list_append(g_client_list, client);
  98
  99         *stt = temp;
 100
 101         return 0;
 102 }
 103
 104 int stt_client_destroy(stt_h stt)
 105 {
 106         if (stt == NULL) {
 107                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
 108                 return 0;
 109         }
 110
 111         GList *iter = NULL;
 112         stt_client_s *data = NULL;
 113
 114         /* if list have item */
 115         if (g_list_length(g_client_list) > 0) {
 116                 /* Get a first item */
 117                 iter = g_list_first(g_client_list);
 118
 119                 while (NULL != iter) {
 120                         data = iter->data;
 121                         if (stt->handle == data->stt->handle) {
 122                                 g_client_list = g_list_remove_link(g_client_list, iter);
 123
 124                                 while (0 != data->cb_ref_count) {
 125                                         /* wait for release callback function */
 126                                 }
 127
 128                                 if (NULL != data->current_engine_id) {
 129                                         free(data->current_engine_id);
 130                                 }
 131
 132                                 if (NULL != data->err_msg) {
 133                                         free(data->err_msg);
 134                                         data->err_msg = NULL;
 135                                 }
 136
 137                                 if (NULL != data->credential) {
 138                                         free(data->credential);
 139                                         data->credential = NULL;
 140                                 }
 141
 142                                 free(data);
 143                                 free(stt);
 144                                 data = NULL;
 145                                 stt = NULL;
 146
 147                                 return 0;
 148                         }
 149
 150                         /* Next item */
 151                         iter = g_list_next(iter);
 152                 }
 153         }
 154
 155         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] client Not founded");
 156
 157         return -1;
 158 }
 159
 160
 161 stt_client_s* stt_client_get(stt_h stt)
 162 {
 163         if (NULL == stt) {
 164                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
 165                 return NULL;
 166         }
 167
 168         GList *iter = NULL;
 169         stt_client_s *data = NULL;
 170
 171         if (g_list_length(g_client_list) > 0) {
 172                 /* Get a first item */
 173                 iter = g_list_first(g_client_list);
 174
 175                 while (NULL != iter) {
 176                         data = iter->data;
 177                         if (NULL != data) {
 178                                 if (stt->handle == data->stt->handle)
 179                                         return data;
 180                         }
 181                         /* Next item */
 182                         iter = g_list_next(iter);
 183                 }
 184         }
 185
 186         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get client by stt");
 187
 188         return NULL;
 189 }
 190
 191 stt_client_s* stt_client_get_by_uid(const int uid)
 192 {
 193         if (uid < 0) {
 194                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] out of range : handle");
 195                 return NULL;
 196         }
 197
 198         GList *iter = NULL;
 199         stt_client_s *data = NULL;
 200
 201         if (g_list_length(g_client_list) > 0) {
 202                 /* Get a first item */
 203                 iter = g_list_first(g_client_list);
 204
 205                 while (NULL != iter) {
 206                         data = iter->data;
 207                         if (uid == data->uid) {
 208                                 return data;
 209                         }
 210
 211                         /* Next item */
 212                         iter = g_list_next(iter);
 213                 }
 214         }
 215
 216         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get client by uid");
 217
 218         return NULL;
 219 }
 220
 221 int stt_client_get_size()
 222 {
 223         return g_list_length(g_client_list);
 224 }
 225
 226 int stt_client_use_callback(stt_client_s* client)
 227 {
 228         client->cb_ref_count++;
 229         return 0;
 230 }
 231
 232 int stt_client_not_use_callback(stt_client_s* client)
 233 {
 234         client->cb_ref_count--;
 235         return 0;
 236 }
 237
 238 int stt_client_get_use_callback(stt_client_s* client)
 239 {
 240         return client->cb_ref_count;
 241 }
 242
 243 GList* stt_client_get_client_list()
 244 {
 245         return g_client_list;
 246 }