server/sttd_client_data.c

   1 /*
   2 *  Copyright (c) 2012, 2013 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 "sttd_main.h"
  16 #include "sttd_client_data.h"
  17
  18 /* Client list */
  19 static GList *g_client_list = NULL;
  20
  21 static GList *g_setting_client_list = NULL;
  22
  23 int client_show_list()
  24 {
  25         GList *iter = NULL;
  26         client_info_s *data = NULL;
  27
  28         SLOG(LOG_DEBUG, TAG_STTD, "----- client list");
  29
  30         if (g_list_length(g_client_list) > 0) {
  31                 /* Get a first item */
  32                 iter = g_list_first(g_client_list);
  33
  34                 int i = 1;
  35                 while (NULL != iter) {
  36                         /*Get handle data from list*/
  37                         data = iter->data;
  38
  39                         SLOG(LOG_DEBUG, TAG_STTD, "[%dth] uid(%d), state(%d)", i, data->uid, data->state);
  40
  41                         /*Get next item*/
  42                         iter = g_list_next(iter);
  43                         i++;
  44                 }
  45         } else {
  46                 SLOG(LOG_DEBUG, TAG_STTD, "No Client");
  47         }
  48
  49         SLOG(LOG_DEBUG, TAG_STTD, "-----");
  50
  51         SLOG(LOG_DEBUG, TAG_STTD, "----- setting client list");
  52
  53         setting_client_info_s *setting_data = NULL;
  54
  55         if (g_list_length(g_setting_client_list) > 0) {
  56                 /* Get a first item */
  57                 iter = g_list_first(g_setting_client_list);
  58
  59                 int i = 1;
  60                 while (NULL != iter) {
  61                         /*Get handle data from list*/
  62                         setting_data = iter->data;
  63
  64                         SLOG(LOG_DEBUG, TAG_STTD, "[%dth] pid(%d)", i, setting_data->pid);
  65
  66                         /*Get next item*/
  67                         iter = g_list_next(iter);
  68                         i++;
  69                 }
  70         } else {
  71                 SLOG(LOG_DEBUG, TAG_STTD, "No setting client");
  72         }
  73
  74         SLOG(LOG_DEBUG, TAG_STTD, "-----");
  75
  76         return 0;
  77 }
  78
  79 GList* __client_get_item(const int uid)
  80 {
  81         GList *iter = NULL;
  82         client_info_s *data = NULL;
  83
  84         if (0 < g_list_length(g_client_list)) {
  85                 iter = g_list_first(g_client_list);
  86
  87                 while (NULL != iter) {
  88                         /* Get handle data from list */
  89                         data = iter->data;
  90
  91                         if (uid == data->uid)
  92                                 return iter;
  93
  94                         iter = g_list_next(iter);
  95                 }
  96         }
  97
  98         return NULL;
  99 }
 100
 101 int sttd_client_add(const int pid, const int uid)
 102 {
 103         /*Check uid is duplicated*/
 104         GList *tmp = NULL;
 105         tmp = __client_get_item(uid);
 106
 107         if (NULL != tmp) {
 108                 SLOG(LOG_WARN, TAG_STTD, "[Client Data] Client uid is already registered");
 109                 return STTD_ERROR_INVALID_PARAMETER;
 110         }
 111
 112         client_info_s *info = (client_info_s*)g_malloc0(sizeof(client_info_s));
 113
 114         info->pid = pid;
 115         info->uid = uid;
 116         info->state = APP_STATE_READY;
 117
 118         /* Add item to global list */
 119         g_client_list = g_list_append(g_client_list, info);
 120
 121         if (NULL == g_client_list) {
 122                 SLOG(LOG_ERROR, TAG_STTD, "[Client Data ERROR] Fail to add new client");
 123                 return -1;
 124         } else {
 125                 SLOG(LOG_DEBUG, TAG_STTD, "[Client Data SUCCESS] Add new client");
 126         }
 127
 128 #ifdef CLIENT_DATA_DEBUG
 129         client_show_list();
 130 #endif
 131         return 0;
 132 }
 133
 134 int sttd_client_delete(const int uid)
 135 {
 136         GList *tmp = NULL;
 137         client_info_s* hnd = NULL;
 138
 139         /*Get handle*/
 140         tmp = __client_get_item(uid);
 141         if (NULL == tmp) {
 142                 SLOG(LOG_ERROR, TAG_STTD, "[Client Data ERROR] uid(%d) is NOT valid", uid);
 143                 return STTD_ERROR_INVALID_PARAMETER;
 144         }
 145
 146         /*Free client structure*/
 147         hnd = tmp->data;
 148         if (NULL != hnd) {
 149                 g_free(hnd);
 150         }
 151
 152         /*Remove handle from list*/
 153         g_client_list = g_list_remove_link(g_client_list, tmp);
 154
 155 #ifdef CLIENT_DATA_DEBUG
 156         client_show_list();
 157 #endif
 158
 159         return 0;
 160 }
 161
 162 int sttd_client_get_state(const int uid, app_state_e* state)
 163 {
 164         GList *tmp = NULL;
 165         client_info_s* hnd = NULL;
 166
 167         tmp = __client_get_item(uid);
 168         if (NULL == tmp) {
 169                 return STTD_ERROR_INVALID_PARAMETER;
 170         }
 171
 172         hnd = tmp->data;
 173         *state = hnd->state;
 174
 175         SLOG(LOG_DEBUG, TAG_STTD, "[Client Data] Get state : uid(%d), state(%d)", uid, *state);
 176
 177         return 0;
 178 }
 179
 180 int sttd_client_set_state(const int uid, const app_state_e state)
 181 {
 182         GList *tmp = NULL;
 183         client_info_s* hnd = NULL;
 184
 185         tmp = __client_get_item(uid);
 186         if (NULL == tmp) {
 187                 SLOG(LOG_ERROR, TAG_STTD, "[Client Data ERROR] uid(%d) is NOT valid", uid);
 188                 return STTD_ERROR_INVALID_PARAMETER;
 189         }
 190
 191         hnd = tmp->data;
 192         hnd->state = state ;
 193
 194         SLOG(LOG_DEBUG, TAG_STTD, "[Client Data SUCCESS] Set state : uid(%d), state(%d)", uid, state);
 195
 196         return 0;
 197 }
 198
 199 int sttd_client_get_ref_count()
 200 {
 201         int count = g_list_length(g_client_list) + g_list_length(g_setting_client_list);
 202         SLOG(LOG_DEBUG, TAG_STTD, "[Client Data] client count : %d", count);
 203
 204         return count;
 205 }
 206
 207 int sttd_client_get_pid(const int uid)
 208 {
 209         GList *tmp = NULL;
 210         client_info_s* hnd = NULL;
 211
 212         tmp = __client_get_item(uid);
 213         if (NULL == tmp) {
 214                 SLOG(LOG_ERROR, TAG_STTD, "[Client Data ERROR] sttd_client_get_pid : uid(%d) is not found", uid);
 215                 return STTD_ERROR_INVALID_PARAMETER;
 216         }
 217
 218         hnd = tmp->data;
 219
 220         return hnd->pid;
 221 }
 222
 223 int sttd_client_get_current_recording()
 224 {
 225         GList *iter = NULL;
 226         client_info_s *data = NULL;
 227
 228         if (0 < g_list_length(g_client_list)) {
 229                 iter = g_list_first(g_client_list);
 230
 231                 while (NULL != iter) {
 232                         /* Get handle data from list */
 233                         data = iter->data;
 234
 235                         if (APP_STATE_RECORDING == data->state)
 236                                 return data->uid;
 237
 238                         iter = g_list_next(iter);
 239                 }
 240         }
 241
 242         return -1;
 243 }
 244
 245 int sttd_client_get_current_thinking()
 246 {
 247         GList *iter = NULL;
 248         client_info_s *data = NULL;
 249
 250         if (0 < g_list_length(g_client_list)) {
 251                 iter = g_list_first(g_client_list);
 252
 253                 while (NULL != iter) {
 254                         /* Get handle data from list */
 255                         data = iter->data;
 256
 257                         if (APP_STATE_PROCESSING == data->state)
 258                                 return data->uid;
 259
 260                         iter = g_list_next(iter);
 261                 }
 262         }
 263
 264         return -1;
 265 }
 266
 267 int sttd_cliet_set_timer(int uid, Ecore_Timer* timer)
 268 {
 269         GList *tmp = NULL;
 270         client_info_s* hnd = NULL;
 271
 272         tmp = __client_get_item(uid);
 273         if (NULL == tmp) {
 274                 SLOG(LOG_ERROR, TAG_STTD, "[Client Data ERROR] uid(%d) is NOT valid", uid);
 275                 return STTD_ERROR_INVALID_PARAMETER;
 276         }
 277
 278         hnd = tmp->data;
 279         hnd->timer = timer;
 280
 281         SLOG(LOG_DEBUG, TAG_STTD, "[Client Data SUCCESS] Set timer : uid(%d)", uid);
 282
 283         return 0;
 284 }
 285
 286 int sttd_cliet_get_timer(int uid, Ecore_Timer** timer)
 287 {
 288         GList *tmp = NULL;
 289         client_info_s* hnd = NULL;
 290
 291         tmp = __client_get_item(uid);
 292         if (NULL == tmp) {
 293                 SLOG(LOG_ERROR, TAG_STTD, "[Client Data ERROR] uid(%d) is NOT valid", uid);
 294                 return STTD_ERROR_INVALID_PARAMETER;
 295         }
 296
 297         hnd = tmp->data;
 298         *timer = hnd->timer;
 299
 300         SLOG(LOG_DEBUG, TAG_STTD, "[Client Data SUCCESS] Get timer : uid(%d)", uid);
 301
 302         return 0;
 303 }
 304
 305
 306 int sttd_client_get_list(int** uids, int* uid_count)
 307 {
 308         if (NULL == uids || NULL == uid_count)
 309                 return -1;
 310
 311         int count = g_list_length(g_client_list);
 312
 313         if (0 == count)
 314                 return -1;
 315
 316         int *tmp;
 317         tmp = (int*)malloc(sizeof(int) * count);
 318
 319         GList *iter = NULL;
 320         client_info_s *data = NULL;
 321         int i = 0;
 322
 323         iter = g_list_first(g_client_list);
 324         for (i = 0;i < count;i++) {
 325                 data = iter->data;
 326                 tmp[i] = data->uid;
 327                 iter = g_list_next(iter);
 328         }
 329
 330         *uids = tmp;
 331         *uid_count = count;
 332
 333         return 0;
 334 }
 335
 336 /*
 337 * Functions for setting
 338 */
 339
 340 GList* __setting_client_get_item(int pid)
 341 {
 342         GList *iter = NULL;
 343         setting_client_info_s *data = NULL;
 344
 345         if (0 < g_list_length(g_setting_client_list)) {
 346                 iter = g_list_first(g_setting_client_list);
 347
 348                 while (NULL != iter) {
 349                         /* Get handle data from list */
 350                         data = iter->data;
 351
 352                         if (pid == data->pid)
 353                                 return iter;
 354
 355                         iter = g_list_next(iter);
 356                 }
 357         }
 358
 359         return NULL;
 360 }
 361
 362 int sttd_setting_client_add(int pid)
 363 {
 364         /* Check uid is duplicated */
 365         GList *tmp = NULL;
 366         tmp = __setting_client_get_item(pid);
 367
 368         if (NULL != tmp) {
 369                 SLOG(LOG_WARN, TAG_STTD, "[Client Data] Setting client(%d) is already registered", pid);
 370                 return STTD_ERROR_INVALID_PARAMETER;
 371         }
 372
 373         setting_client_info_s *info = (setting_client_info_s*)g_malloc0(sizeof(setting_client_info_s));
 374
 375         info->pid = pid;
 376
 377         /* Add item to global list */
 378         g_setting_client_list = g_list_append(g_setting_client_list, info);
 379
 380         if (NULL == g_setting_client_list) {
 381                 SLOG(LOG_ERROR, TAG_STTD, "[Client Data ERROR] Fail to add new client");
 382                 return -1;
 383         } else {
 384                 SLOG(LOG_DEBUG, TAG_STTD, "[Client Data SUCCESS] Add new client");
 385         }
 386
 387 #ifdef CLIENT_DATA_DEBUG
 388         client_show_list();
 389 #endif
 390         return 0;
 391 }
 392
 393 int sttd_setting_client_delete(int pid)
 394 {
 395         GList *tmp = NULL;
 396         setting_client_info_s* hnd = NULL;
 397
 398         /*Get handle*/
 399         tmp = __setting_client_get_item(pid);
 400         if (NULL == tmp) {
 401                 SLOG(LOG_ERROR, TAG_STTD, "[Client Data ERROR] Setting uid(%d) is NOT valid", pid);
 402                 return STTD_ERROR_INVALID_PARAMETER;
 403         }
 404
 405         /*Free client structure*/
 406         hnd = tmp->data;
 407         if (NULL != hnd) {
 408                 g_free(hnd);
 409         }
 410
 411         /*Remove handle from list*/
 412         g_setting_client_list = g_list_remove_link(g_setting_client_list, tmp);
 413
 414 #ifdef CLIENT_DATA_DEBUG
 415         client_show_list();
 416 #endif
 417
 418         return 0;
 419 }
 420
 421 bool sttd_setting_client_is(int pid)
 422 {
 423         GList *tmp = __setting_client_get_item(pid);
 424         if (NULL == tmp) {
 425                 return false;
 426         }
 427
 428         return true;
 429 }