server/ttse.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 "ttsd_main.h"
  16 #include "ttsd_server.h"
  17 #include "ttsd_dbus.h"
  18 #include "ttsd_network.h"
  19
  20 #include <bundle.h>
  21 #include <bundle_internal.h>
  22 #include <dlog.h>
  23 #include <Ecore.h>
  24
  25 #include "ttse.h"
  26
  27 #define CLIENT_CLEAN_UP_TIME 500
  28
  29 static Ecore_Timer* g_check_client_timer = NULL;
  30
  31 static ttsd_mode_e g_tts_mode = TTSD_MODE_DEFAULT;
  32
  33 const char* tts_tag()
  34 {
  35         if (TTSD_MODE_NOTIFICATION == g_tts_mode) {
  36                 return "ttsdnoti";
  37         } else if (TTSD_MODE_SCREEN_READER == g_tts_mode) {
  38                 return "ttsdsr";
  39         } else {
  40                 return "ttsd";
  41         }
  42 }
  43
  44 ttsd_mode_e ttsd_get_mode()
  45 {
  46         return g_tts_mode;
  47 }
  48
  49 void ttsd_set_mode(ttsd_mode_e mode)
  50 {
  51         g_tts_mode = mode;
  52         return;
  53 }
  54
  55 int ttse_main(int argc, char** argv, ttse_request_callback_s *callback)
  56 {
  57         bundle *b = NULL;
  58         ttsd_mode_e mode = TTSD_MODE_DEFAULT;
  59         int ret = TTSE_ERROR_NONE;
  60
  61         b = bundle_import_from_argv(argc, argv);
  62         if (NULL != b) {
  63                 char *val = NULL;
  64                 if (0 == bundle_get_str(b, "mode", &val)) {
  65                         if (NULL != val) {
  66                                 if (!strcmp("noti", val)) {
  67                                         mode = TTSD_MODE_NOTIFICATION;
  68                                 } else if (!strcmp("sr", val)) {
  69                                         mode = TTSD_MODE_SCREEN_READER;
  70                                 } else {
  71                                         SLOG(LOG_WARN, tts_tag(), "[WARNING] mode (%s)", val);
  72                                 }
  73                         } else {
  74                                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] NULL data");
  75                         }
  76                 } else {
  77                         SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get data from bundle");
  78                 }
  79                 bundle_free(b);
  80                 val = NULL;
  81         } else {
  82                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get bundle");
  83         }
  84
  85         ttsd_set_mode(mode);
  86
  87         SLOG(LOG_DEBUG, tts_tag(), "Start engine as [%d] mode", mode);
  88
  89         if (!ecore_init()) {
  90                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to initialize Ecore");
  91                 return TTSE_ERROR_OPERATION_FAILED;
  92         }
  93
  94         if (0 != ttsd_dbus_open_connection()) {
  95                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to open dbus connection");
  96                 ecore_shutdown();
  97                 return TTSE_ERROR_OPERATION_FAILED;
  98         }
  99
 100         ret = ttsd_initialize(callback);
 101         if (0 != ret) {
 102                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to initialize");
 103                 ttsd_dbus_close_connection();
 104                 ecore_shutdown();
 105                 return ret;
 106         }
 107
 108         if (0 != ttsd_network_initialize()) {
 109                 SLOG(LOG_WARN, tts_tag(), "[WARNING] Fail to initialize network");
 110         }
 111
 112         g_check_client_timer = ecore_timer_add(CLIENT_CLEAN_UP_TIME, ttsd_cleanup_client, NULL);
 113         if (NULL == g_check_client_timer) {
 114                 SLOG(LOG_WARN, tts_tag(), "[WARNING] Fail to create timer");
 115         }
 116
 117         SLOG(LOG_DEBUG, tts_tag(), "====");
 118         SLOG(LOG_DEBUG, tts_tag(), "");
 119
 120         return TTSE_ERROR_NONE;
 121 }
 122
 123 int ttse_get_speed_range(int* min, int* normal, int* max)
 124 {
 125         if (NULL == min || NULL == normal || NULL == max) {
 126                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Input parameter is null");
 127                 return TTSE_ERROR_INVALID_PARAMETER;
 128         }
 129
 130         *min = TTS_SPEED_MIN;
 131         *normal = TTS_SPEED_NORMAL;
 132         *max = TTS_SPEED_MAX;
 133
 134         return 0;
 135 }
 136
 137 int ttse_get_pitch_range(int* min, int* normal, int* max)
 138 {
 139         if (NULL == min || NULL == normal || NULL == max) {
 140                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Input parameter is null");
 141                 return TTSE_ERROR_INVALID_PARAMETER;
 142         }
 143
 144         *min = TTS_PITCH_MIN;
 145         *normal = TTS_PITCH_NORMAL;
 146         *max = TTS_PITCH_MAX;
 147
 148         return 0;
 149 }
 150
 151 int ttse_send_result(ttse_result_event_e event, const void* data, unsigned int data_size, ttse_audio_type_e audio_type, int rate, void* user_data)
 152 {
 153         int ret;
 154
 155         if (NULL == data) {
 156                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Input parameter is null");
 157         }
 158
 159         ret = ttsd_send_result(event, data, data_size, audio_type, rate, user_data);
 160
 161         if (0 != ret) {
 162                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to send result");
 163         }
 164
 165         return ret;
 166 }
 167
 168 int ttse_send_error(ttse_error_e error, const char* msg)
 169 {
 170         int ret;
 171
 172         if (NULL == msg) {
 173                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Input parameter is null");
 174                 return TTSE_ERROR_INVALID_PARAMETER;
 175         }
 176
 177         ret = ttsd_send_error(error, msg);
 178
 179         if (0 != ret) {
 180                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to send error");
 181         }
 182
 183         return ret;
 184 }
 185
 186 int ttse_set_private_data_set_cb(ttse_private_data_set_cb callback_func)
 187 {
 188         if (NULL == callback_func) {
 189                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Invalid parameter");
 190                 return TTSE_ERROR_INVALID_PARAMETER;
 191         }
 192
 193         int ret = ttsd_set_private_data_set_cb(callback_func);
 194
 195         if (0 != ret) {
 196                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to set private data set cb");
 197         }
 198
 199         return ret;
 200 }
 201
 202 int ttse_set_private_data_requested_cb(ttse_private_data_requested_cb callback_func)
 203 {
 204         if (NULL == callback_func) {
 205                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Invalid parameter");
 206                 return TTSE_ERROR_INVALID_PARAMETER;
 207         }
 208
 209         int ret = ttsd_set_private_data_requested_cb(callback_func);
 210
 211         if (0 != ret) {
 212                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to set private data requested cb");
 213         }
 214
 215         return ret;
 216 }