server/dependency_audio_manager.cpp

   1 /**
   2  * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <stdlib.h>
  18 #include <dlfcn.h>
  19
  20 #include <stdexcept>
  21
  22 #include <tizen.h>
  23 #include <dlog.h>
  24 #include <vconf.h>
  25
  26 #include "dependency_audio_manager.h"
  27
  28 #ifdef LOG_TAG
  29 #undef LOG_TAG
  30 #endif
  31 #define LOG_TAG "dependency_am"
  32
  33
  34 static void *g_lib_handle = NULL;
  35 static vcd_dependency_module_interface g_interface = { NULL, };
  36
  37
  38 int dependency_audio_manager_initialize(sound_stream_info_h stream_info_h, dependency_audio_manager_feed_audio_data callback)
  39 {
  40         SLOG(LOG_DEBUG, LOG_TAG, "@@@ initialize");
  41
  42         const int FILEPATH_LEN = 512;
  43         char filepath[FILEPATH_LEN] = {'\0', };
  44         const char *module_directory_path = VCD_DEPENDENCY_MODULE_DIRECTORY_PATH;
  45         char *module_library_name = vconf_get_str(VCD_DEPENDENCY_MODULE_NAME);
  46         if (module_library_name) {
  47                 snprintf(filepath, FILEPATH_LEN - 1, "%s/%s", module_directory_path, module_library_name);
  48                 free(module_library_name);
  49         } else {
  50                 snprintf(filepath, FILEPATH_LEN - 1, "%s/%s", module_directory_path, VCD_DEPENDENCY_DEFAULT_FILENAME);
  51         }
  52         filepath[FILEPATH_LEN - 1] = '\0';
  53
  54         char *error;
  55         g_lib_handle = NULL;
  56         g_lib_handle = dlopen(filepath, RTLD_LAZY);
  57         if (NULL != (error = dlerror())) {
  58                 SLOG(LOG_ERROR, LOG_TAG, "[ERROR] Fail to dlopen(%s), error(%s)", filepath, error);
  59                 return -1; //MAS_ERROR_OPERATION_FAILED;
  60         }
  61
  62         g_interface.initialize =
  63                 (vcd_dependency_initialize)dlsym(g_lib_handle, VCD_DEPENDENCY_FUNC_INITIALIZE);
  64         g_interface.deinitialize =
  65                 (vcd_dependency_deinitialize)dlsym(g_lib_handle, VCD_DEPENDENCY_FUNC_DEINITIALIZE);
  66         g_interface.set_audio_info =
  67                 (vcd_dependency_set_audio_info)dlsym(g_lib_handle, VCD_DEPENDENCY_FUNC_SET_AUDIO_INFO);
  68         g_interface.get_audio_source_type =
  69                 (vcd_dependency_get_audio_source_type)dlsym(g_lib_handle, VCD_DEPENDENCY_FUNC_GET_AUDIO_SOURCE_TYPE);
  70         g_interface.set_streaming_mode =
  71                 (vcd_dependency_set_streaming_mode)dlsym(g_lib_handle, VCD_DEPENDENCY_FUNC_SET_STREAMING_MODE);
  72         g_interface.start_recording =
  73                 (vcd_dependency_start_recording)dlsym(g_lib_handle, VCD_DEPENDENCY_FUNC_START_RECORDING);
  74         g_interface.stop_recording =
  75                 (vcd_dependency_stop_recording)dlsym(g_lib_handle, VCD_DEPENDENCY_FUNC_STOP_RECORDING);
  76
  77         int ret = 0;
  78         if (NULL != g_lib_handle) {
  79                 vcd_dependency_initialize func = g_interface.initialize;
  80
  81                 if (NULL == func) {
  82                         SLOG(LOG_ERROR, LOG_TAG, "[ERROR] symbol lookup failed : %s", VCD_DEPENDENCY_FUNC_INITIALIZE);
  83                 } else {
  84                         try {
  85                                 ret = func(stream_info_h, callback);
  86                         } catch (const std::exception& e) {
  87                                 SLOG(LOG_ERROR, LOG_TAG, "[ERROR] %s of dependency module threw exception : %s",
  88                                         VCD_DEPENDENCY_FUNC_INITIALIZE, e.what());
  89                         }
  90
  91                         if (0 != ret) {
  92                                 SLOG(LOG_ERROR, LOG_TAG, "[ERROR] Fail to initialize, ret(%d)", ret);
  93                         }
  94                 }
  95         } else {
  96                 SLOG(LOG_ERROR, LOG_TAG, "[ERROR] g_lib_handle is not valid");
  97         }
  98
  99         SLOG(LOG_DEBUG, LOG_TAG, "@@@");
 100         return ret;
 101 }
 102
 103 int dependency_audio_manager_deinitialize(void)
 104 {
 105         SLOG(LOG_DEBUG, LOG_TAG, "@@@ Deinitialize");
 106         int ret = 0;
 107         if (NULL != g_lib_handle) {
 108                 vcd_dependency_deinitialize func = g_interface.deinitialize;
 109
 110                 if (NULL == func) {
 111                         SLOG(LOG_ERROR, LOG_TAG, "[ERROR] symbol lookup failed : %s", VCD_DEPENDENCY_FUNC_DEINITIALIZE);
 112                 } else {
 113                         try {
 114                                 ret = func();
 115                         } catch (const std::exception& e) {
 116                                 SLOG(LOG_ERROR, LOG_TAG, "[ERROR] %s of dependency module threw exception : %s",
 117                                         VCD_DEPENDENCY_FUNC_DEINITIALIZE, e.what());
 118                         }
 119
 120                         if (0 != ret) {
 121                                 SLOG(LOG_ERROR, LOG_TAG, "[ERROR] Fail to initialize, ret(%d)", ret);
 122                         }
 123                 }
 124
 125                 dlclose(g_lib_handle);
 126                 g_lib_handle = NULL;
 127         } else {
 128                 SLOG(LOG_ERROR, LOG_TAG, "[ERROR] g_lib_handle is not valid");
 129         }
 130
 131         SLOG(LOG_DEBUG, LOG_TAG, "@@@");
 132         return ret;
 133 }
 134
 135 int dependency_audio_manager_set_audio_info(sound_stream_info_h stream_info_h, const char* audio_source_type, vce_audio_type_e type, int rate, int channel)
 136 {
 137         SLOG(LOG_DEBUG, LOG_TAG, "@@@ Set audio information");
 138         int ret = 0;
 139         if (NULL != g_lib_handle) {
 140                 vcd_dependency_set_audio_info func = g_interface.set_audio_info;
 141
 142                 if (NULL == func) {
 143                         SLOG(LOG_ERROR, LOG_TAG, "[ERROR] symbol lookup failed : %s", VCD_DEPENDENCY_FUNC_SET_AUDIO_INFO);
 144                 } else {
 145                         try {
 146                                 ret = func(stream_info_h, audio_source_type, type, rate, channel);
 147                         } catch (const std::exception& e) {
 148                                 SLOG(LOG_ERROR, LOG_TAG, "[ERROR] %s of dependency module threw exception : %s",
 149                                         VCD_DEPENDENCY_FUNC_SET_AUDIO_INFO, e.what());
 150                         }
 151
 152                         if (0 != ret) {
 153                                 SLOG(LOG_ERROR, LOG_TAG, "[ERROR] Fail to initialize, ret(%d)", ret);
 154                         }
 155                 }
 156         } else {
 157                 SLOG(LOG_ERROR, LOG_TAG, "[ERROR] g_lib_handle is not valid");
 158         }
 159
 160         SLOG(LOG_DEBUG, LOG_TAG, "@@@");
 161         return ret;
 162 }
 163
 164 int dependency_audio_manager_get_audio_source_type(char** audio_source_type)
 165 {
 166         SLOG(LOG_DEBUG, LOG_TAG, "@@@ Get audio source type");
 167         int ret = 0;
 168         if (NULL != g_lib_handle) {
 169                 vcd_dependency_get_audio_source_type func = g_interface.get_audio_source_type;
 170
 171                 if (NULL == func) {
 172                         SLOG(LOG_ERROR, LOG_TAG, "[ERROR] symbol lookup failed : %s", VCD_DEPENDENCY_FUNC_GET_AUDIO_SOURCE_TYPE);
 173                 } else {
 174                         try {
 175                                 ret = func(audio_source_type);
 176                         } catch (const std::exception& e) {
 177                                 SLOG(LOG_ERROR, LOG_TAG, "[ERROR] %s of dependency module threw exception : %s",
 178                                         VCD_DEPENDENCY_FUNC_GET_AUDIO_SOURCE_TYPE, e.what());
 179                         }
 180
 181                         if (0 != ret) {
 182                                 SLOG(LOG_ERROR, LOG_TAG, "[ERROR] Fail to initialize, ret(%d)", ret);
 183                         }
 184                 }
 185         } else {
 186                 SLOG(LOG_ERROR, LOG_TAG, "[ERROR] g_lib_handle is not valid");
 187         }
 188
 189         SLOG(LOG_DEBUG, LOG_TAG, "@@@");
 190         return ret;
 191 }
 192
 193 int dependency_audio_manager_set_streaming_mode(vc_audio_streaming_mode_e mode)
 194 {
 195         SLOG(LOG_DEBUG, LOG_TAG, "@@@ Set streaming mode");
 196         int ret = 0;
 197         if (NULL != g_lib_handle) {
 198                 vcd_dependency_set_streaming_mode func = g_interface.set_streaming_mode;
 199
 200                 if (NULL == func) {
 201                         SLOG(LOG_ERROR, LOG_TAG, "[ERROR] symbol lookup failed : %s", VCD_DEPENDENCY_FUNC_SET_STREAMING_MODE);
 202                 } else {
 203                         try {
 204                                 ret = func(mode);
 205                         } catch (const std::exception& e) {
 206                                 SLOG(LOG_ERROR, LOG_TAG, "[ERROR] %s of dependency module threw exception : %s",
 207                                         VCD_DEPENDENCY_FUNC_SET_STREAMING_MODE, e.what());
 208                         }
 209
 210                         if (0 != ret) {
 211                                 SLOG(LOG_ERROR, LOG_TAG, "[ERROR] Fail to set streaming mode, ret(%d)", ret);
 212                         }
 213                 }
 214         } else {
 215                 SLOG(LOG_ERROR, LOG_TAG, "[ERROR] g_lib_handle is not valid");
 216         }
 217
 218         SLOG(LOG_DEBUG, LOG_TAG, "@@@");
 219         return ret;
 220 }
 221
 222 int dependency_audio_manager_start_recording(void)
 223 {
 224         SLOG(LOG_DEBUG, LOG_TAG, "@@@ Start recording");
 225         int ret = 0;
 226         if (NULL != g_lib_handle) {
 227                 vcd_dependency_start_recording func = g_interface.start_recording;
 228
 229                 if (NULL == func) {
 230                         SLOG(LOG_ERROR, LOG_TAG, "[ERROR] symbol lookup failed : %s", VCD_DEPENDENCY_FUNC_START_RECORDING);
 231                 } else {
 232                         try {
 233                                 ret = func();
 234                         } catch (const std::exception& e) {
 235                                 SLOG(LOG_ERROR, LOG_TAG, "[ERROR] %s of dependency module threw exception : %s",
 236                                         VCD_DEPENDENCY_FUNC_START_RECORDING, e.what());
 237                         }
 238
 239                         if (0 != ret) {
 240                                 SLOG(LOG_ERROR, LOG_TAG, "[ERROR] Fail to initialize, ret(%d)", ret);
 241                         }
 242                 }
 243         } else {
 244                 SLOG(LOG_ERROR, LOG_TAG, "[ERROR] g_lib_handle is not valid");
 245         }
 246
 247         SLOG(LOG_DEBUG, LOG_TAG, "@@@");
 248         return ret;
 249
 250 }
 251
 252 int dependency_audio_manager_stop_recording(void)
 253 {
 254         SLOG(LOG_DEBUG, LOG_TAG, "@@@ Stop recording");
 255         int ret = 0;
 256         if (NULL != g_lib_handle) {
 257                 vcd_dependency_stop_recording func = g_interface.stop_recording;
 258
 259                 if (NULL == func) {
 260                         SLOG(LOG_ERROR, LOG_TAG, "[ERROR] symbol lookup failed : %s", VCD_DEPENDENCY_FUNC_STOP_RECORDING);
 261                 } else {
 262                         try {
 263                                 ret = func();
 264                         } catch (const std::exception& e) {
 265                                 SLOG(LOG_ERROR, LOG_TAG, "[ERROR] %s of dependency module threw exception : %s",
 266                                         VCD_DEPENDENCY_FUNC_STOP_RECORDING, e.what());
 267                         }
 268
 269                         if (0 != ret) {
 270                                 SLOG(LOG_ERROR, LOG_TAG, "[ERROR] Fail to initialize, ret(%d)", ret);
 271                         }
 272                 }
 273         } else {
 274                 SLOG(LOG_ERROR, LOG_TAG, "[ERROR] g_lib_handle is not valid");
 275         }
 276
 277         SLOG(LOG_DEBUG, LOG_TAG, "@@@");
 278         return ret;
 279 }