src/tapi_proxy_sound.c

   1 /*
   2  * libslp-tapi
   3  *
   4  * Copyright (c) 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Ja-young Gu <jygu@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */
  20
  21
  22 #include "tel_cs_conn.h"
  23 #include "tapi_proxy.h"
  24 #include "ITapiSound.h"
  25 #include "TapiUtility.h"
  26 #include "TelErr.h"
  27 #include "TelUtility.h"
  28
  29 extern tapi_dbus_connection_name conn_name;
  30
  31 /**
  32  *
  33  * send to Telephony Server to get the volume status of the phone
  34  *
  35  * @return              TAPI_API_SUCCESS on success and one of the enum types of  TapiResult_t on failure
  36  * @param[in]           tapi_sound_volume_type_t
  37  * @param[out]  None
  38  * @Interface           Asynchronous.
  39  * @remark
  40  * @Refer               tapi_sound_volume_control_set
  41  *
  42  */
  43 EXPORT_API int tel_get_sound_volume_info(tapi_sound_volume_type_t vol_control_type, int *pRequestId)
  44 {
  45         TS_BOOL ret;
  46         int api_err;
  47
  48         TAPI_LIB_DEBUG(LEVEL_DEBUG,"Func Entrance ");
  49         TAPI_RETURN_VAL_IF_FAIL(pRequestId, TAPI_API_INVALID_PTR);
  50
  51         if (conn_name.length_of_name == 0) {
  52                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
  53                 return TAPI_API_OPERATION_FAILED;
  54         }
  55
  56         if ((vol_control_type != TAPI_SOUND_VOL_VOICE)
  57                         && (vol_control_type != TAPI_SOUND_VOL_KEYTONE)
  58                         && (vol_control_type != TAPI_SOUND_VOL_BELL)
  59                         && (vol_control_type != TAPI_SOUND_VOL_MESSAGE)
  60                         && (vol_control_type != TAPI_SOUND_VOL_ALARM)
  61                         && (vol_control_type != TAPI_SOUND_VOL_SPK_PHONE)
  62                         && (vol_control_type != TAPI_SOUND_VOL_HFK_VOICE)
  63                         && (vol_control_type != TAPI_SOUND_VOL_HFK_KEYTONE)
  64                         && (vol_control_type != TAPI_SOUND_VOL_HFK_BELL)
  65                         && (vol_control_type != TAPI_SOUND_VOL_HFK_MESSAGE)
  66                         && (vol_control_type != TAPI_SOUND_VOL_HFK_ALARM)
  67                         && (vol_control_type != TAPI_SOUND_VOL_HFK_PDA_MISC)
  68                         && (vol_control_type != TAPI_SOUND_VOL_HEADSET_VOICE)
  69                         && (vol_control_type != TAPI_SOUND_VOL_BT_VOICE)
  70                         && (vol_control_type != TAPI_SOUND_VOL_TYPE_ALL)) {
  71                 TAPI_LIB_DEBUG(LEVEL_DEBUG,"Invalid Input for vol_control_type = %x", vol_control_type);
  72                 return TAPI_API_INVALID_INPUT;
  73         }
  74
  75         TAPI_GLIB_INIT_PARAMS();
  76
  77         /*       check for the RPC link....     */
  78         TAPI_RET_ERR_NUM_IF_FAIL(tapi_check_dbus_status(),
  79                         TAPI_API_SYSTEM_RPC_LINK_NOT_EST);
  80
  81         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,
  82                         out_param1,out_param2,out_param3,out_param4);
  83
  84         g_array_append_vals(in_param1, &vol_control_type, sizeof(tapi_sound_volume_type_t));
  85         g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
  86
  87         ret = tapi_send_request(TAPI_CS_SERVICE_SOUND, TAPI_CS_SOUND_VOLUME_GET, in_param1, in_param2, in_param3,
  88                         in_param4, &out_param1, &out_param2, &out_param3, &out_param4);
  89
  90         if (ret) {
  91                 api_err = g_array_index(out_param1, int, 0);
  92                 *pRequestId = g_array_index(out_param2, int, 0);
  93         }
  94         else {
  95                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
  96                 TAPI_LIB_DEBUG(LEVEL_DEBUG,"proxy error = %x ",api_err);
  97         }
  98
  99         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,
 100                         out_param1,out_param2,out_param3,out_param4);
 101
 102         return api_err;
 103 }
 104
 105 /**
 106  *
 107  * send to Telephony Server to control the phone voulume
 108  *
 109  * @return              TAPI_API_SUCCESS on success and one of the enum types of  TapiResult_t on failure
 110  * @param[in]           tapi_sound_volume_control_t
 111  * @param[out]  None
 112  * @Interface           Asynchronous.
 113  * @remark
 114  * @Refer               tapi_sound_volume_control_get
 115  *
 116  */
 117 EXPORT_API int tel_set_sound_volume_info(tapi_sound_volume_control_t vol_control, int *pRequestId)
 118 {
 119         TS_BOOL ret;
 120         int api_err;
 121
 122         TAPI_LIB_DEBUG(LEVEL_DEBUG,"Func Entrance ");
 123         TAPI_RETURN_VAL_IF_FAIL(pRequestId, TAPI_API_INVALID_PTR);
 124
 125         if ((vol_control.volume > TAPI_SOUND_VOLUME_LEVEL_9) || (vol_control.volume < TAPI_SOUND_MUTE)) {
 126                 TAPI_LIB_DEBUG(LEVEL_DEBUG,"Invalid Input for vol_control.volume = %x", vol_control.volume);
 127                 return TAPI_API_INVALID_INPUT;
 128         }
 129
 130         if ((vol_control.vol_type != TAPI_SOUND_VOL_VOICE)
 131                         && (vol_control.vol_type != TAPI_SOUND_VOL_KEYTONE)
 132                         && (vol_control.vol_type != TAPI_SOUND_VOL_BELL)
 133                         && (vol_control.vol_type != TAPI_SOUND_VOL_MESSAGE)
 134                         && (vol_control.vol_type != TAPI_SOUND_VOL_ALARM)
 135                         && (vol_control.vol_type != TAPI_SOUND_VOL_SPK_PHONE)
 136                         && (vol_control.vol_type != TAPI_SOUND_VOL_HFK_VOICE)
 137                         && (vol_control.vol_type != TAPI_SOUND_VOL_HFK_KEYTONE)
 138                         && (vol_control.vol_type != TAPI_SOUND_VOL_HFK_KEYTONE)
 139                         && (vol_control.vol_type != TAPI_SOUND_VOL_HFK_MESSAGE)
 140                         && (vol_control.vol_type != TAPI_SOUND_VOL_HFK_ALARM)
 141                         && (vol_control.vol_type != TAPI_SOUND_VOL_HFK_PDA_MISC)
 142                         && (vol_control.vol_type != TAPI_SOUND_VOL_HEADSET_VOICE)
 143                         && (vol_control.vol_type != TAPI_SOUND_VOL_BT_VOICE)
 144                         && (vol_control.vol_type != TAPI_SOUND_VOL_TYPE_ALL)) {
 145                 TAPI_LIB_DEBUG(LEVEL_DEBUG,"Invalid Input for vol_control.vol_type = %x", vol_control.vol_type);
 146                 return TAPI_API_INVALID_INPUT;
 147         }
 148
 149         TAPI_GLIB_INIT_PARAMS();
 150
 151         /*       check for the RPC link....     */
 152         TAPI_RET_ERR_NUM_IF_FAIL(tapi_check_dbus_status(),
 153                         TAPI_API_SYSTEM_RPC_LINK_NOT_EST);
 154
 155         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,
 156                         out_param1,out_param2,out_param3,out_param4);
 157
 158         g_array_append_vals(in_param1, &vol_control, sizeof(tapi_sound_volume_control_t));
 159
 160         ret = tapi_send_request(TAPI_CS_SERVICE_SOUND, TAPI_CS_SOUND_VOLUME_SET, in_param1, in_param2, in_param3,
 161                         in_param4, &out_param1, &out_param2, &out_param3, &out_param4);
 162
 163         if (ret) {
 164                 api_err = g_array_index(out_param1, int, 0);
 165                 *pRequestId = g_array_index(out_param2, int, 0);
 166         }
 167         else {
 168                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 169                 TAPI_LIB_DEBUG(LEVEL_DEBUG,"proxy error = %x ",api_err);
 170         }
 171
 172         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,
 173                         out_param1,out_param2,out_param3,out_param4);
 174
 175         return api_err;
 176 }
 177
 178 /**
 179  *
 180  * Send to Telephony Server to set voice path
 181  *
 182  * @return              TAPI_API_SUCCESS on success and one of the enum types of  TapiResult_t on failure
 183  * @param[in]           tapi_sound_audio_path_t
 184  * @param[out]  None
 185  * @Interface           Asynchronous.
 186  * @remark
 187  * @Refer
 188  *
 189  **/
 190 EXPORT_API int tel_set_sound_path(tapi_sound_audio_path_t vc_path, int *pRequestId)
 191 {
 192         TS_BOOL ret;
 193         int api_err;
 194
 195         TAPI_LIB_DEBUG(LEVEL_DEBUG,"Func Entrance ");
 196         TAPI_RETURN_VAL_IF_FAIL(pRequestId, TAPI_API_INVALID_PTR);
 197
 198         if ((vc_path > TAPI_SOUND_HEADSET_HAC) || (vc_path < TAPI_SOUND_HANDSET)) {
 199                 TAPI_LIB_DEBUG(LEVEL_DEBUG,"Invalid Input for vc_path = %x", vc_path);
 200                 return TAPI_API_INVALID_INPUT;
 201         }
 202
 203         TAPI_GLIB_INIT_PARAMS();
 204
 205         TAPI_RET_ERR_NUM_IF_FAIL(tapi_check_dbus_status(), TAPI_API_SYSTEM_RPC_LINK_DOWN);
 206
 207         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,
 208                         out_param1,out_param2,out_param3,out_param4);
 209
 210         g_array_append_vals(in_param1, &vc_path, sizeof(tapi_sound_audio_path_t));
 211
 212         ret = tapi_send_request(TAPI_CS_SERVICE_SOUND, TAPI_CS_SOUND_AUDIO_PATH_CTRL, in_param1, in_param2, in_param3,
 213                         in_param4, &out_param1, &out_param2, &out_param3, &out_param4);
 214
 215         if (ret) {
 216                 api_err = g_array_index(out_param1, int, 0);
 217                 *pRequestId = g_array_index(out_param2, int, 0);
 218         }
 219         else {
 220                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 221                 TAPI_LIB_DEBUG(LEVEL_DEBUG,"proxy error = %x ",api_err);
 222         }
 223
 224         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,
 225                         out_param1,out_param2,out_param3,out_param4);
 226
 227         return api_err;
 228 }
 229
 230 /**
 231  *
 232  * Send to Telehpny Server to control  the microphone as mute during the call.
 233  *
 234  * @param       tapi_sound_mic_mute_t
 235  * @param[out]  None
 236  * @Interface           Asynchronous.
 237  * @return      enum type TapiResult_t
 238  * @remark
 239  *
 240  * @Refer               tapi_sound_micmute_control_get
 241  */
 242 EXPORT_API int tel_set_sound_mute_status(tapi_sound_mic_mute_t micmute_set, int *pRequestId)
 243 {
 244         TS_BOOL ret;
 245         int api_err;
 246
 247         TAPI_LIB_DEBUG(LEVEL_DEBUG,"Func Entrance... mic mute [%s] ", micmute_set? "MUTE" : "UNMUTE");
 248         TAPI_RETURN_VAL_IF_FAIL(pRequestId, TAPI_API_INVALID_PTR);
 249
 250         if ((micmute_set > TAPI_SOUND_MIC_MUTE) || (micmute_set < TAPI_SOUND_MIC_UNMUTE)) {
 251                 TAPI_LIB_DEBUG(LEVEL_DEBUG,"Invalid Input for micmute_get = %x", micmute_set);
 252                 return TAPI_API_INVALID_INPUT;
 253         }
 254
 255         TAPI_GLIB_INIT_PARAMS();
 256
 257         /*       check for the RPC link....     */
 258         TAPI_RET_ERR_NUM_IF_FAIL(tapi_check_dbus_status(),
 259                         TAPI_API_SYSTEM_RPC_LINK_NOT_EST);
 260
 261         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,
 262                         out_param1,out_param2,out_param3,out_param4);
 263
 264         g_array_append_vals(in_param1, &micmute_set, sizeof(tapi_sound_mic_mute_t));
 265
 266         ret = tapi_send_request(TAPI_CS_SERVICE_SOUND, TAPI_CS_SOUND_MIC_MUTE_SET, in_param1, in_param2, in_param3,
 267                         in_param4, &out_param1, &out_param2, &out_param3, &out_param4);
 268
 269         if (ret) {
 270                 api_err = g_array_index(out_param1, int, 0);
 271                 *pRequestId = g_array_index(out_param2, int, 0);
 272         }
 273         else {
 274                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 275                 TAPI_LIB_DEBUG(LEVEL_DEBUG,"proxy error = %x ", api_err);
 276         }
 277
 278         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,
 279                         out_param1,out_param2,out_param3,out_param4);
 280
 281         return api_err;
 282 }
 283
 284 /**
 285  *
 286  * send to Telephony Server to get the status whether mic mute or not
 287  *
 288  * @return              TAPI_API_SUCCESS on success and one of the enum types of  TapiResult_t on failure
 289  * @param[in]           None
 290  * @param[out]  None
 291  * @Interface           Asynchronous.
 292  * @remark
 293  * @Refer               tapi_sound_micgain_control_set
 294  *
 295  */
 296 EXPORT_API int tel_get_sound_mute_status(int *pRequestId)
 297 {
 298         TS_BOOL ret;
 299         int api_err;
 300
 301         TAPI_LIB_DEBUG(LEVEL_DEBUG,"Func Entrance ");
 302         TAPI_RETURN_VAL_IF_FAIL(pRequestId, TAPI_API_INVALID_PTR);
 303
 304         if (conn_name.length_of_name == 0) {
 305                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
 306                 return TAPI_API_OPERATION_FAILED;
 307         }
 308
 309         TAPI_GLIB_INIT_PARAMS();
 310
 311         /*       check for the RPC link....     */
 312         TAPI_RET_ERR_NUM_IF_FAIL(tapi_check_dbus_status(), TAPI_API_SYSTEM_RPC_LINK_NOT_EST);
 313
 314         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,
 315                         out_param1,out_param2,out_param3,out_param4);
 316
 317         g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
 318
 319         ret = tapi_send_request(TAPI_CS_SERVICE_SOUND, TAPI_CS_SOUND_MIC_MUTE_GET, in_param1, in_param2, in_param3,
 320                         in_param4, &out_param1, &out_param2, &out_param3, &out_param4);
 321
 322         if (ret) {
 323                 api_err = g_array_index(out_param1, int, 0);
 324                 *pRequestId = g_array_index(out_param2, int, 0);
 325         }
 326         else {
 327                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 328                 TAPI_LIB_DEBUG(LEVEL_DEBUG,"proxy error = %x ",api_err);
 329         }
 330
 331         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,
 332                         out_param1,out_param2,out_param3,out_param4);
 333
 334         return api_err;
 335 }
 336
 337
 338 /**
 339  * Process the starting Audio Loopback test.
 340  *
 341  * @return              TapiResult_t            API result code. Either Success or some Error Code.
 342  * @param[in]
 343  * @param[out]
 344  * @Changes
 345  */
 346 EXPORT_API int tel_set_sound_loopback(TelAudioLoopbackMode_t *Mode, int *pRequestId)
 347 {
 348         TS_BOOL ret = FALSE;
 349         int api_err = TAPI_API_SUCCESS;
 350
 351         TAPI_LIB_DEBUG(LEVEL_DEBUG, "Func Entrance ");
 352
 353         TAPI_RET_ERR_NUM_IF_FAIL(tapi_check_dbus_status_internal(), TAPI_API_SYSTEM_RPC_LINK_NOT_EST);
 354         TAPI_RETURN_VAL_IF_FAIL(pRequestId, TAPI_API_INVALID_PTR);
 355
 356         if (Mode->path > TAPI_SOUND_HEADSET_3_5PI || Mode->path < TAPI_SOUND_HANDSET) {
 357                 TAPI_LIB_DEBUG(LEVEL_DEBUG, "Invalid Input for path = %x", Mode->path);
 358                 return TAPI_API_INVALID_INPUT;
 359         }
 360
 361         if (Mode->status > TAPI_SOUND_AUDIO_LOOPBACK_PACKET_ON || Mode->status < TAPI_SOUND_AUDIO_LOOPBACK_OFF) {
 362                 TAPI_LIB_DEBUG(LEVEL_DEBUG, "Invalid Input for status = %x", Mode->status);
 363                 return TAPI_API_INVALID_INPUT;
 364         }
 365
 366         TAPI_GLIB_INIT_PARAMS();
 367         TAPI_GLIB_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param1, out_param2, out_param3, out_param4);
 368
 369         g_array_append_vals(in_param1, Mode, sizeof(TelAudioLoopbackMode_t));
 370
 371         ret = tapi_send_request_internal(TAPI_CS_SERVICE_SOUND, TAPI_CS_SOUND_AUDIOLOOPBACK_SET,
 372                         in_param1, in_param2, in_param3, in_param4,
 373                         &out_param1, &out_param2, &out_param3, &out_param4);
 374
 375         if (TRUE == ret) {
 376                 api_err = g_array_index(out_param1, int, 0);
 377                 *pRequestId = g_array_index(out_param2, int, 0);
 378         }
 379         else {
 380                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 381                 TAPI_LIB_DEBUG(LEVEL_DEBUG,"proxy error = %x ",api_err);
 382         }
 383
 384         TAPI_GLIB_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param1, out_param2, out_param3, out_param4);
 385
 386         return api_err;
 387 }
 388
 389 /**
 390  * Process the control of audio clock
 391  *
 392  * @return              TapiResult_t            API result code. Either Success or some Error Code.
 393  * @param[in]
 394  * @param[out]
 395  * @Changes
 396  */
 397 EXPORT_API int tel_set_sound_clock(int bEnable, int *pRequestId)
 398 {
 399         TS_BOOL ret = FALSE;
 400         int api_err = TAPI_API_SUCCESS;
 401
 402         TAPI_LIB_DEBUG(LEVEL_DEBUG, "Func Entrance ");
 403
 404         TAPI_RET_ERR_NUM_IF_FAIL(tapi_check_dbus_status_internal(), TAPI_API_SYSTEM_RPC_LINK_NOT_EST);
 405         TAPI_RETURN_VAL_IF_FAIL(pRequestId, TAPI_API_INVALID_PTR);
 406
 407         if (bEnable > TRUE || bEnable < FALSE) {
 408                 TAPI_LIB_DEBUG(LEVEL_DEBUG, "Invalid Input for bEnable = %x", bEnable);
 409                 return TAPI_API_INVALID_INPUT;
 410         }
 411
 412         TAPI_GLIB_INIT_PARAMS();
 413         TAPI_GLIB_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param1, out_param2, out_param3, out_param4);
 414
 415         g_array_append_vals(in_param1, &bEnable, sizeof(int));
 416
 417         ret = tapi_send_request_internal(TAPI_CS_SERVICE_SOUND, TAPI_CS_SOUND_AUDIO_CLOCK_CTRL,
 418                         in_param1, in_param2, in_param3, in_param4,
 419                         &out_param1, &out_param2, &out_param3, &out_param4);
 420
 421         if (TRUE == ret) {
 422                 api_err = g_array_index(out_param1, int, 0);
 423                 *pRequestId = g_array_index(out_param2, int, 0);
 424         }
 425         else {
 426                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 427                 TAPI_LIB_DEBUG(LEVEL_DEBUG,"proxy error = %x ",api_err);
 428         }
 429
 430         TAPI_GLIB_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param1, out_param2, out_param3, out_param4);
 431
 432         return api_err;
 433 }
 434
 435 /**
 436  *
 437  * send to Telephony Server to control the voice call recording
 438  *
 439  * @return              TAPI_API_SUCCESS on success and one of the enum types of  TapiResult_t on failure
 440  * @param[in]           None
 441  * @param[out]  None
 442  * @Interface           Asynchronous.
 443  * @remark
 444  * @Refer               tapi_sound_micgain_control_set
 445  *
 446  */
 447 EXPORT_API int tel_control_sound_voice_recording(tapi_sound_voice_recording_status_t voice_record, int *pRequestId)
 448 {
 449         TS_BOOL ret;
 450         int api_err;
 451
 452         TAPI_LIB_DEBUG(LEVEL_DEBUG, "Func Entrance... voice_record [%d] ", voice_record);
 453
 454         TAPI_RET_ERR_NUM_IF_FAIL(tapi_check_dbus_status_internal(), TAPI_API_SYSTEM_RPC_LINK_NOT_EST);
 455         TAPI_RETURN_VAL_IF_FAIL(pRequestId, TAPI_API_INVALID_PTR);
 456
 457         if (voice_record < TAPI_SOUND_VOICE_RECORDING_OFF || voice_record > TAPI_SOUND_VOICE_RECORDING_ON) {
 458                 TAPI_LIB_DEBUG(LEVEL_DEBUG, "Invalid Input for voice recoring = %x", voice_record);
 459                 return TAPI_API_INVALID_INPUT;
 460         }
 461
 462         TAPI_GLIB_INIT_PARAMS();
 463         TAPI_GLIB_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param1, out_param2, out_param3, out_param4);
 464
 465         g_array_append_vals(in_param1, &voice_record, sizeof(tapi_sound_voice_recording_status_t));
 466
 467         ret = tapi_send_request_internal(TAPI_CS_SERVICE_SOUND, TAPI_CS_SOUND_VOICE_RECORDING_SET,
 468                         in_param1, in_param2, in_param3, in_param4,
 469                         &out_param1, &out_param2, &out_param3, &out_param4);
 470
 471         if (ret) {
 472                 api_err = g_array_index(out_param1, int, 0);
 473                 *pRequestId = g_array_index(out_param2, int, 0);
 474         }
 475         else {
 476                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 477                 TAPI_LIB_DEBUG(LEVEL_DEBUG,"proxy error = %x ", api_err);
 478         }
 479
 480         TAPI_GLIB_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param1, out_param2, out_param3, out_param4);
 481
 482         return api_err;
 483 }
 484
 485 // eof