plugin/src/socket_call.c

   1 /*
   2  * tel-plugin-socket-communicator
   3  *
   4  * Copyright (c) 2012 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 #include <stdio.h>
  22 #include <string.h>
  23 #include <stdlib.h>
  24 #include <errno.h>
  25 #include <glib-object.h>
  26
  27 #include <aul.h>
  28 #include <bundle.h>
  29 #include <tcore.h>
  30 #include <server.h>
  31 #include <plugin.h>
  32 #include <hal.h>
  33 #include <communicator.h>
  34 #include <core_object.h>
  35 #include <queue.h>
  36 #include <user_request.h>
  37 #include <util.h>
  38 #include <co_call.h>
  39
  40 #include "sipc.h"
  41 #include "tapi_common.h"
  42 #include "module_req.h"
  43
  44 gboolean scomm_service_reqeust_call(unsigned int ch_id, Communicator *c, TcorePlugin *plugin, tapi_service_command_e cmd, gchar *data, void **outparam)
  45 {
  46         int ret = 0;
  47         gboolean result = TRUE; int err_cause = 0;
  48         int s_data_len = 0;
  49         gchar *serial_d = NULL;
  50
  51         GSList *co_list = NULL;
  52         CoreObject *co_call = NULL;
  53         UserRequest *ur = NULL;
  54         struct tcore_user_info ui = { 0, 0, 0, NULL,0,0, NULL };
  55
  56         struct _sipc_marshal_object *out_obj;
  57         struct _sipc_marshal_object *in_obj;
  58
  59         co_list = tcore_plugin_get_core_objects_bytype(plugin, CORE_OBJECT_TYPE_CALL);
  60         if (!co_list) {
  61                 return FALSE;
  62         }
  63
  64         co_call = (CoreObject *)co_list->data;
  65         if (!co_call) {
  66                 return FALSE;
  67         }
  68         g_slist_free(co_list);
  69
  70         in_obj = sipc_util_marshal_object_deserializer(data);
  71         if(in_obj){
  72                 return FALSE;
  73         }
  74
  75         ui.channel_id = ch_id;
  76         ui.client_cmd = (unsigned int)cmd;
  77         ur = tcore_user_request_new(c, tcore_plugin_get_description(plugin)->name);
  78         if (!ur) {
  79                 return FALSE;
  80         }
  81         tcore_user_request_set_user_info(ur, &ui);
  82
  83         switch (cmd) {
  84                 case TAPI_SERVICE_CALL_DIAL: {
  85                         struct treq_call_dial data;
  86                         /*
  87                          * COMMON CODE
  88                          * get_data from in_obj
  89                          *
  90                          * ONLY SYNC API & RETURN DATA
  91                          * out_obj = sipc_util_marshal_object_create();
  92                          * sipc_util_marshal_object_add_data(out_obj, "result", &result, SIPC_MARSHAL_DATA_BOOLEAN_TYPE);
  93                          * sipc_util_marshal_object_add_data(out_obj, "err_cause", &err_cause, SIPC_MARSHAL_DATA_BOOLEAN_INT);
  94                          *
  95                          * serial_d = sipc_util_marshal_object_serializer(out_obj);
  96                          * s_data_len = strlen(serial_d);
  97                          * sipc_util_marshal_object_destory(out_obj);
  98                          *
  99                          * *outparam = g_new0(char, s_data_len);
 100                          * memcpy(*outparam, serial_d, hdr.s_data_len);
 101                          * g_free(serial_d);
 102                          * return;
 103                          *
 104                          */
 105                         tcore_user_request_set_data(ur, sizeof( struct treq_call_dial ), &data);
 106                         tcore_user_request_set_command(ur, TREQ_CALL_DIAL);
 107                 }break;
 108                 case TAPI_SERVICE_ANSWER: {
 109                         struct treq_call_answer data;
 110                         /*
 111                          * COMMON CODE
 112                          * get_data from in_obj
 113                          *
 114                          * ONLY SYNC API & RETURN DATA
 115                          * out_obj = sipc_util_marshal_object_create();
 116                          * sipc_util_marshal_object_add_data(out_obj, "result", &result, SIPC_MARSHAL_DATA_BOOLEAN_TYPE);
 117                          * sipc_util_marshal_object_add_data(out_obj, "err_cause", &err_cause, SIPC_MARSHAL_DATA_BOOLEAN_INT);
 118                          *
 119                          * serial_d = sipc_util_marshal_object_serializer(out_obj);
 120                          * s_data_len = strlen(serial_d);
 121                          * sipc_util_marshal_object_destory(out_obj);
 122                          *
 123                          * *outparam = g_new0(char, s_data_len);
 124                          * memcpy(*outparam, serial_d, hdr.s_data_len);
 125                          * g_free(serial_d);
 126                          * return;
 127                          *
 128                          */
 129                         tcore_user_request_set_data(ur, sizeof( struct treq_call_answer ), &data);
 130                         tcore_user_request_set_command(ur, TREQ_CALL_ANSWER);
 131                 }break;
 132                 case TAPI_SERVICE_END: {
 133                         //TAPI_CS_CALL_RELEASEALL
 134                         //TAPI_CS_CALL_RELEASEALL_ACTIVE
 135                         //TAPI_CS_CALL_RELEASEALL_HELD
 136                         struct treq_call_end data;
 137                         /*
 138                          * COMMON CODE
 139                          * get_data from in_obj
 140                          *
 141                          * ONLY SYNC API & RETURN DATA
 142                          * out_obj = sipc_util_marshal_object_create();
 143                          * sipc_util_marshal_object_add_data(out_obj, "result", &result, SIPC_MARSHAL_DATA_BOOLEAN_TYPE);
 144                          * sipc_util_marshal_object_add_data(out_obj, "err_cause", &err_cause, SIPC_MARSHAL_DATA_BOOLEAN_INT);
 145                          *
 146                          * serial_d = sipc_util_marshal_object_serializer(out_obj);
 147                          * s_data_len = strlen(serial_d);
 148                          * sipc_util_marshal_object_destory(out_obj);
 149                          *
 150                          * *outparam = g_new0(char, s_data_len);
 151                          * memcpy(*outparam, serial_d, hdr.s_data_len);
 152                          * g_free(serial_d);
 153                          * return;
 154                          *
 155                          */
 156                         tcore_user_request_set_data(ur, sizeof( struct treq_call_end ), &data);
 157                         tcore_user_request_set_command(ur, TREQ_CALL_END);
 158                 }break;
 159
 160                 //TAPI_CS_CALL_DTMF
 161
 162                 case TAPI_SERVICE_HOLD: {
 163                         unsigned int id = 0;
 164                         /*
 165                          * COMMON CODE
 166                          * get_data from in_obj
 167                          *
 168                          * ONLY SYNC API & RETURN DATA
 169                          * out_obj = sipc_util_marshal_object_create();
 170                          * sipc_util_marshal_object_add_data(out_obj, "result", &result, SIPC_MARSHAL_DATA_BOOLEAN_TYPE);
 171                          * sipc_util_marshal_object_add_data(out_obj, "err_cause", &err_cause, SIPC_MARSHAL_DATA_BOOLEAN_INT);
 172                          *
 173                          * serial_d = sipc_util_marshal_object_serializer(out_obj);
 174                          * s_data_len = strlen(serial_d);
 175                          * sipc_util_marshal_object_destory(out_obj);
 176                          *
 177                          * *outparam = g_new0(char, s_data_len);
 178                          * memcpy(*outparam, serial_d, hdr.s_data_len);
 179                          * g_free(serial_d);
 180                          * return;
 181                          *
 182                          */
 183                         tcore_user_request_set_data(ur, sizeof( unsigned int ), &id);
 184                         tcore_user_request_set_command(ur, TREQ_CALL_HOLD);
 185                 }break;
 186                 case TAPI_SERVICE_ACTIVE: {
 187                         unsigned int id = 0;
 188                         /*
 189                          * COMMON CODE
 190                          * get_data from in_obj
 191                          *
 192                          * ONLY SYNC API & RETURN DATA
 193                          * out_obj = sipc_util_marshal_object_create();
 194                          * sipc_util_marshal_object_add_data(out_obj, "result", &result, SIPC_MARSHAL_DATA_BOOLEAN_TYPE);
 195                          * sipc_util_marshal_object_add_data(out_obj, "err_cause", &err_cause, SIPC_MARSHAL_DATA_BOOLEAN_INT);
 196                          *
 197                          * serial_d = sipc_util_marshal_object_serializer(out_obj);
 198                          * s_data_len = strlen(serial_d);
 199                          * sipc_util_marshal_object_destory(out_obj);
 200                          *
 201                          * *outparam = g_new0(char, s_data_len);
 202                          * memcpy(*outparam, serial_d, hdr.s_data_len);
 203                          * g_free(serial_d);
 204                          * return;
 205                          *
 206                          */
 207                         tcore_user_request_set_data(ur, sizeof( unsigned int ), &id);
 208                         tcore_user_request_set_command(ur, TREQ_CALL_ACTIVE);
 209                 }break;
 210                 case TAPI_SERVICE_SWAP: {
 211                         unsigned int id = 0;
 212                         /*
 213                          * COMMON CODE
 214                          * get_data from in_obj
 215                          *
 216                          * ONLY SYNC API & RETURN DATA
 217                          * out_obj = sipc_util_marshal_object_create();
 218                          * sipc_util_marshal_object_add_data(out_obj, "result", &result, SIPC_MARSHAL_DATA_BOOLEAN_TYPE);
 219                          * sipc_util_marshal_object_add_data(out_obj, "err_cause", &err_cause, SIPC_MARSHAL_DATA_BOOLEAN_INT);
 220                          *
 221                          * serial_d = sipc_util_marshal_object_serializer(out_obj);
 222                          * s_data_len = strlen(serial_d);
 223                          * sipc_util_marshal_object_destory(out_obj);
 224                          *
 225                          * *outparam = g_new0(char, s_data_len);
 226                          * memcpy(*outparam, serial_d, hdr.s_data_len);
 227                          * g_free(serial_d);
 228                          * return;
 229                          *
 230                          */
 231                         tcore_user_request_set_data(ur, sizeof( unsigned int ), &id);
 232                         tcore_user_request_set_command(ur, TREQ_CALL_SWAP);
 233                 }break;
 234                 case TAPI_SERVICE_JOIN: {
 235                         unsigned int id = 0;
 236                         /*
 237                          * COMMON CODE
 238                          * get_data from in_obj
 239                          *
 240                          * ONLY SYNC API & RETURN DATA
 241                          * out_obj = sipc_util_marshal_object_create();
 242                          * sipc_util_marshal_object_add_data(out_obj, "result", &result, SIPC_MARSHAL_DATA_BOOLEAN_TYPE);
 243                          * sipc_util_marshal_object_add_data(out_obj, "err_cause", &err_cause, SIPC_MARSHAL_DATA_BOOLEAN_INT);
 244                          *
 245                          * serial_d = sipc_util_marshal_object_serializer(out_obj);
 246                          * s_data_len = strlen(serial_d);
 247                          * sipc_util_marshal_object_destory(out_obj);
 248                          *
 249                          * *outparam = g_new0(char, s_data_len);
 250                          * memcpy(*outparam, serial_d, hdr.s_data_len);
 251                          * g_free(serial_d);
 252                          * return;
 253                          *
 254                          */
 255                         tcore_user_request_set_data(ur, sizeof( unsigned int ), &id);
 256                         tcore_user_request_set_command(ur, TREQ_CALL_JOIN);
 257                 }break;
 258                 case TAPI_SERVICE_SPLIT: {
 259                         unsigned int id = 0;
 260                         /*
 261                          * COMMON CODE
 262                          * get_data from in_obj
 263                          *
 264                          * ONLY SYNC API & RETURN DATA
 265                          * out_obj = sipc_util_marshal_object_create();
 266                          * sipc_util_marshal_object_add_data(out_obj, "result", &result, SIPC_MARSHAL_DATA_BOOLEAN_TYPE);
 267                          * sipc_util_marshal_object_add_data(out_obj, "err_cause", &err_cause, SIPC_MARSHAL_DATA_BOOLEAN_INT);
 268                          *
 269                          * serial_d = sipc_util_marshal_object_serializer(out_obj);
 270                          * s_data_len = strlen(serial_d);
 271                          * sipc_util_marshal_object_destory(out_obj);
 272                          *
 273                          * *outparam = g_new0(char, s_data_len);
 274                          * memcpy(*outparam, serial_d, hdr.s_data_len);
 275                          * g_free(serial_d);
 276                          * return;
 277                          *
 278                          */
 279                         tcore_user_request_set_data(ur, sizeof( unsigned int ), &id);
 280                         tcore_user_request_set_command(ur, TREQ_CALL_SPLIT);
 281                 }break;
 282                 case TAPI_SERVICE_DEFLECT: {
 283                         /*
 284                          * COMMON CODE
 285                          * get_data from in_obj
 286                          *
 287                          * ONLY SYNC API & RETURN DATA
 288                          * out_obj = sipc_util_marshal_object_create();
 289                          * sipc_util_marshal_object_add_data(out_obj, "result", &result, SIPC_MARSHAL_DATA_BOOLEAN_TYPE);
 290                          * sipc_util_marshal_object_add_data(out_obj, "err_cause", &err_cause, SIPC_MARSHAL_DATA_BOOLEAN_INT);
 291                          *
 292                          * serial_d = sipc_util_marshal_object_serializer(out_obj);
 293                          * s_data_len = strlen(serial_d);
 294                          * sipc_util_marshal_object_destory(out_obj);
 295                          *
 296                          * *outparam = g_new0(char, s_data_len);
 297                          * memcpy(*outparam, serial_d, hdr.s_data_len);
 298                          * g_free(serial_d);
 299                          * return;
 300                          *
 301                          */
 302                         tcore_user_request_set_command(ur, TREQ_CALL_DEFLECT);
 303                 }break;
 304                 case TAPI_SERVICE_TRANSFER: {
 305                         unsigned int id = 0;
 306                         /*
 307                          * COMMON CODE
 308                          * get_data from in_obj
 309                          *
 310                          * ONLY SYNC API & RETURN DATA
 311                          * out_obj = sipc_util_marshal_object_create();
 312                          * sipc_util_marshal_object_add_data(out_obj, "result", &result, SIPC_MARSHAL_DATA_BOOLEAN_TYPE);
 313                          * sipc_util_marshal_object_add_data(out_obj, "err_cause", &err_cause, SIPC_MARSHAL_DATA_BOOLEAN_INT);
 314                          *
 315                          * serial_d = sipc_util_marshal_object_serializer(out_obj);
 316                          * s_data_len = strlen(serial_d);
 317                          * sipc_util_marshal_object_destory(out_obj);
 318                          *
 319                          * *outparam = g_new0(char, s_data_len);
 320                          * memcpy(*outparam, serial_d, hdr.s_data_len);
 321                          * g_free(serial_d);
 322                          * return;
 323                          *
 324                          */
 325                         tcore_user_request_set_data(ur, sizeof( unsigned int ), &id);
 326                         tcore_user_request_set_command(ur, TREQ_CALL_TRANSFER);
 327                 }break;
 328
 329                 //TAPI_CS_CALL_GETACTIVELINE
 330                 //TAPI_CS_CALL_SETACTIVELINE
 331
 332                 case TAPI_SERVICE_SEND_DTMF: {}break;
 333                 case TAPI_SERVICE_SET_SOUND_PATH: {}break;
 334                 case TAPI_SERVICE_GET_SOUND_VOLUME_LEVEL: {}break;
 335                 case TAPI_SERVICE_SET_SOUND_VOLUME_LEVEL: {}break;
 336                 case TAPI_SERVICE_MUTE: {}break;
 337                 case TAPI_SERVICE_UNMUTE: {}break;
 338                 case TAPI_SERVICE_GET_MUTE_STATUS: {}break;
 339         }
 340
 341         ret = tcore_communicator_dispatch_request(c, ur);
 342         if (ret != TCORE_RETURN_SUCCESS) {
 343                 return FALSE;
 344         }
 345
 346         return TRUE;
 347 }
 348
 349 gboolean scomm_service_response_call(Communicator *comm, UserRequest *ur, enum tcore_response_command command, unsigned int data_len, const void *data)
 350 {
 351         int ret = 0;
 352
 353         gboolean result = TRUE; int err_cause = 0;
 354         gchar *out_d= NULL, *serial_d = NULL;
 355         struct custom_data *ctx = NULL;
 356         const struct tcore_user_info *ui;
 357
 358         sipc_server_t *s = NULL;
 359         struct _tapi_header hdr;
 360         struct _sipc_marshal_object* out_obj = NULL;
 361
 362         memset(&hdr, 0, sizeof(struct _tapi_header));
 363
 364         ctx = tcore_communicator_ref_user_data(comm);
 365         if (!ctx) {
 366                 dbg("user_data is NULL");
 367                 return FALSE;
 368         }
 369
 370         ui = tcore_user_request_ref_user_info(ur);
 371         s = ctx->sk_server;
 372
 373         dbg("application channel id(%d), Command = [0x%x], data_len = %d", ui->channel_id, command, data_len);
 374         hdr.cmd = (tapi_service_command_e)ui->client_cmd;
 375
 376         switch (command) {
 377                 case TRESP_CALL_DIAL: {
 378                         struct tresp_call_general* resp_data = 0;
 379                         resp_data = (struct tresp_call_general*)data;
 380
 381                         /*{create output data and create serialized data}
 382                                 out_obj = sipc_util_marshal_object_create();
 383                                 sipc_util_marshal_object_add_data(out_obj, "result", &result, SIPC_MARSHAL_DATA_BOOLEAN_TYPE);
 384                                 sipc_util_marshal_object_add_data(out_obj, "err_cause", &err_cause, SIPC_MARSHAL_DATA_BOOLEAN_INT);
 385                                 .......
 386                         */
 387                 } break;
 388
 389                 case TRESP_CALL_ANSWER: {
 390                         struct tresp_call_general* resp_data = 0;
 391                         resp_data = (struct tresp_call_general*)data;
 392
 393                         /*{create output data and create serialized data}
 394                                 out_obj = sipc_util_marshal_object_create();
 395                                 sipc_util_marshal_object_add_data(out_obj, "result", &result, SIPC_MARSHAL_DATA_BOOLEAN_TYPE);
 396                                 sipc_util_marshal_object_add_data(out_obj, "err_cause", &err_cause, SIPC_MARSHAL_DATA_BOOLEAN_INT);
 397                                 .......
 398                         */
 399                 } break;
 400
 401                 case TRESP_CALL_END: {
 402                         struct tresp_call_general* resp_data = 0;
 403                         resp_data = (struct tresp_call_general*)data;
 404
 405                         /*{create output data and create serialized data}
 406                                 out_obj = sipc_util_marshal_object_create();
 407                                 sipc_util_marshal_object_add_data(out_obj, "result", &result, SIPC_MARSHAL_DATA_BOOLEAN_TYPE);
 408                                 sipc_util_marshal_object_add_data(out_obj, "err_cause", &err_cause, SIPC_MARSHAL_DATA_BOOLEAN_INT);
 409                                 .......
 410                         */
 411
 412                 } break;
 413                 case TRESP_CALL_END_ALL: {
 414                         struct tresp_call_general* resp_data = 0;
 415                         resp_data = (struct tresp_call_general*)data;
 416
 417                         /*{create output data and create serialized data}
 418                                 out_obj = sipc_util_marshal_object_create();
 419                                 sipc_util_marshal_object_add_data(out_obj, "result", &result, SIPC_MARSHAL_DATA_BOOLEAN_TYPE);
 420                                 sipc_util_marshal_object_add_data(out_obj, "err_cause", &err_cause, SIPC_MARSHAL_DATA_BOOLEAN_INT);
 421                                 .......
 422                         */
 423
 424                 } break;
 425                 case TRESP_CALL_END_ALL_ACTIVE: {
 426                         struct tresp_call_general* resp_data = 0;
 427                         resp_data = (struct tresp_call_general*)data;
 428
 429                         /*{create output data and create serialized data}
 430                                 out_obj = sipc_util_marshal_object_create();
 431                                 sipc_util_marshal_object_add_data(out_obj, "result", &result, SIPC_MARSHAL_DATA_BOOLEAN_TYPE);
 432                                 sipc_util_marshal_object_add_data(out_obj, "err_cause", &err_cause, SIPC_MARSHAL_DATA_BOOLEAN_INT);
 433                                 .......
 434                         */
 435                 } break;
 436                 case TRESP_CALL_END_ALL_HELD: {
 437                         struct tresp_call_general* resp_data = 0;
 438                         resp_data = (struct tresp_call_general*)data;
 439
 440                         /*{create output data and create serialized data}
 441                                 out_obj = sipc_util_marshal_object_create();
 442                                 sipc_util_marshal_object_add_data(out_obj, "result", &result, SIPC_MARSHAL_DATA_BOOLEAN_TYPE);
 443                                 sipc_util_marshal_object_add_data(out_obj, "err_cause", &err_cause, SIPC_MARSHAL_DATA_BOOLEAN_INT);
 444                                 .......
 445                         */
 446                 } break;
 447                 case TRESP_CALL_HOLD: {
 448                         struct tresp_call_general* resp_data = 0;
 449                         resp_data = (struct tresp_call_general*)data;
 450
 451                         /*{create output data and create serialized data}
 452                                 out_obj = sipc_util_marshal_object_create();
 453                                 sipc_util_marshal_object_add_data(out_obj, "result", &result, SIPC_MARSHAL_DATA_BOOLEAN_TYPE);
 454                                 sipc_util_marshal_object_add_data(out_obj, "err_cause", &err_cause, SIPC_MARSHAL_DATA_BOOLEAN_INT);
 455                                 .......
 456                         */
 457                 } break;
 458                 case TRESP_CALL_ACTIVE: {
 459                         struct tresp_call_general* resp_data = 0;
 460                         resp_data = (struct tresp_call_general*)data;
 461
 462                         /*{create output data and create serialized data}
 463                                 out_obj = sipc_util_marshal_object_create();
 464                                 sipc_util_marshal_object_add_data(out_obj, "result", &result, SIPC_MARSHAL_DATA_BOOLEAN_TYPE);
 465                                 sipc_util_marshal_object_add_data(out_obj, "err_cause", &err_cause, SIPC_MARSHAL_DATA_BOOLEAN_INT);
 466                                 .......
 467                         */
 468                 } break;
 469                 case TRESP_CALL_SWAP: {
 470                         struct tresp_call_general* resp_data = 0;
 471                         resp_data = (struct tresp_call_general*)data;
 472
 473                         /*{create output data and create serialized data}
 474                                 out_obj = sipc_util_marshal_object_create();
 475                                 sipc_util_marshal_object_add_data(out_obj, "result", &result, SIPC_MARSHAL_DATA_BOOLEAN_TYPE);
 476                                 sipc_util_marshal_object_add_data(out_obj, "err_cause", &err_cause, SIPC_MARSHAL_DATA_BOOLEAN_INT);
 477                                 .......
 478                         */
 479                 } break;
 480                 case TRESP_CALL_JOIN: {
 481                         struct tresp_call_general* resp_data = 0;
 482                         resp_data = (struct tresp_call_general*)data;
 483
 484                         /*{create output data and create serialized data}
 485                                 out_obj = sipc_util_marshal_object_create();
 486                                 sipc_util_marshal_object_add_data(out_obj, "result", &result, SIPC_MARSHAL_DATA_BOOLEAN_TYPE);
 487                                 sipc_util_marshal_object_add_data(out_obj, "err_cause", &err_cause, SIPC_MARSHAL_DATA_BOOLEAN_INT);
 488                                 .......
 489                         */
 490                 } break;
 491                 case TRESP_CALL_SPLIT: {
 492                         struct tresp_call_general* resp_data = 0;
 493                         resp_data = (struct tresp_call_general*)data;
 494
 495                         /*{create output data and create serialized data}
 496                                 out_obj = sipc_util_marshal_object_create();
 497                                 sipc_util_marshal_object_add_data(out_obj, "result", &result, SIPC_MARSHAL_DATA_BOOLEAN_TYPE);
 498                                 sipc_util_marshal_object_add_data(out_obj, "err_cause", &err_cause, SIPC_MARSHAL_DATA_BOOLEAN_INT);
 499                                 .......
 500                         */
 501                 } break;
 502                 case TRESP_CALL_DEFLECT: {
 503
 504                 } break;
 505                 case TRESP_CALL_TRANSFER: {
 506                         struct tresp_call_general* resp_data = 0;
 507                         resp_data = (struct tresp_call_general*)data;
 508
 509                         /*{create output data and create serialized data}
 510                                 out_obj = sipc_util_marshal_object_create();
 511                                 sipc_util_marshal_object_add_data(out_obj, "result", &result, SIPC_MARSHAL_DATA_BOOLEAN_TYPE);
 512                                 sipc_util_marshal_object_add_data(out_obj, "err_cause", &err_cause, SIPC_MARSHAL_DATA_BOOLEAN_INT);
 513                                 .......
 514                         */
 515                 } break;
 516                 case TRESP_CALL_SEND_DTMF: {
 517
 518                 } break;
 519                 case TRESP_CALL_SET_SOUND_PATH: {
 520                         struct tresp_call_sound_general* resp_data = 0;
 521                         //tapi_sound_error_info_t error_info = { 0 };
 522
 523                         resp_data = (struct tresp_call_sound_general*)data;
 524
 525                         /*{create output data and create serialized data}
 526                                 out_obj = sipc_util_marshal_object_create();
 527                                 sipc_util_marshal_object_add_data(out_obj, "result", &result, SIPC_MARSHAL_DATA_BOOLEAN_TYPE);
 528                                 sipc_util_marshal_object_add_data(out_obj, "err_cause", &err_cause, SIPC_MARSHAL_DATA_BOOLEAN_INT);
 529                                 .......
 530                         */
 531                 } break;
 532
 533                 case TRESP_CALL_SET_SOUND_VOLUME_LEVEL: {
 534                         struct tresp_call_sound_general* resp_data = 0;
 535                         //tapi_sound_error_info_t error_info = { 0 };
 536                         unsigned int err = 0;
 537
 538                         resp_data = (struct tresp_call_sound_general*)data;
 539
 540                         /*{create output data and create serialized data}
 541                                 out_obj = sipc_util_marshal_object_create();
 542                                 sipc_util_marshal_object_add_data(out_obj, "result", &result, SIPC_MARSHAL_DATA_BOOLEAN_TYPE);
 543                                 sipc_util_marshal_object_add_data(out_obj, "err_cause", &err_cause, SIPC_MARSHAL_DATA_BOOLEAN_INT);
 544                                 .......
 545                         */
 546                 } break;
 547
 548                 case TRESP_CALL_GET_SOUND_VOLUME_LEVEL: {
 549
 550                 } break;
 551
 552                 case TRESP_CALL_MUTE:
 553                 case TRESP_CALL_UNMUTE: {
 554                         struct tresp_call_sound_general* resp_data = 0;
 555                         //tapi_sound_error_info_t error_info = { 0 };
 556                         unsigned int err = 0;
 557
 558                         resp_data = (struct tresp_call_sound_general*)data;
 559
 560                         /*{create output data and create serialized data}
 561                                 out_obj = sipc_util_marshal_object_create();
 562                                 sipc_util_marshal_object_add_data(out_obj, "result", &result, SIPC_MARSHAL_DATA_BOOLEAN_TYPE);
 563                                 sipc_util_marshal_object_add_data(out_obj, "err_cause", &err_cause, SIPC_MARSHAL_DATA_BOOLEAN_INT);
 564                                 .......
 565                         */
 566                 } break;
 567
 568                 case TRESP_CALL_GET_MUTE_STATUS: {
 569
 570                 } break;
 571
 572                 default:
 573                         break;
 574         }
 575
 576         if(out_obj){
 577                 serial_d = sipc_util_marshal_object_serializer(out_obj);
 578                 hdr.data_len = strlen(serial_d);
 579                 sipc_util_marshal_object_destory(out_obj);
 580         }
 581
 582         out_d = g_new0(char, sizeof(struct _tapi_header)+hdr.data_len);
 583         memcpy(out_d, &hdr, sizeof(struct _tapi_header));
 584         if(serial_d){
 585                 memcpy(out_d+sizeof(struct _tapi_header), serial_d, hdr.data_len);
 586                 g_free(serial_d);
 587         }
 588
 589         ret = sipc_server_send(s, ui->channel_id, out_d, sizeof(struct _tapi_header)+hdr.data_len, SIPC_SEND_DATA_ASYNC);
 590         g_free(out_d);
 591
 592         if(ret < 0){
 593                 return FALSE;
 594         }
 595
 596         return TRUE;
 597 }
 598
 599 gboolean scomm_service_notification_call(Communicator *comm, CoreObject *source, enum tcore_notification_command command, unsigned int data_len, const void *data)
 600 {
 601         int ret = 0;
 602         gboolean result = TRUE; int err_cause = 0;
 603         gchar *out_d= NULL, *serial_d = NULL;
 604
 605         struct custom_data *ctx = NULL;
 606         sipc_server_t *s = NULL;
 607
 608         struct _tapi_header hdr;
 609         struct _sipc_marshal_object* out_obj = NULL;
 610
 611         memset(&hdr, 0, sizeof(struct _tapi_header));
 612
 613         ctx = tcore_communicator_ref_user_data(comm);
 614         if (!ctx) {
 615                 dbg("user_data is NULL");
 616                 return FALSE;
 617         }
 618
 619         s = ctx->sk_server;
 620         dbg("notification !!! (command = 0x%x, data_len = %d)", command, data_len);
 621
 622         switch (command) {
 623                 case TNOTI_CALL_STATUS_IDLE: {
 624                         //TelCallEndInfo_t resp_data;
 625                         int *id = (int*)data;
 626
 627                         //resp_data.CallEndCause        = 0;
 628                         //resp_data.pCallHandle = *id;
 629                         //resp_data.CallStartTime = 0;
 630                         //resp_data.CallEndTime = 0;
 631
 632                         /*{create output data and create serialized data}
 633                                 hdr->cmd = ;
 634                                 out_obj = sipc_util_marshal_object_create();
 635                                 sipc_util_marshal_object_add_data(out_obj, "result", &result, SIPC_MARSHAL_DATA_BOOLEAN_TYPE);
 636                                 sipc_util_marshal_object_add_data(out_obj, "err_cause", &err_cause, SIPC_MARSHAL_DATA_BOOLEAN_INT);
 637                                 .......
 638                         */
 639
 640                         //TAPI_EVENT_CLASS_CALL_VOICE,
 641                         //TAPI_EVENT_CALL_END_IND,
 642                 }
 643                         break;
 644
 645                 case TNOTI_CALL_STATUS_DIALING:
 646                         break;
 647
 648                 case TNOTI_CALL_STATUS_ALERT:
 649
 650                         /*{create output data and create serialized data}
 651                                 hdr->cmd = ;
 652                                 out_obj = sipc_util_marshal_object_create();
 653                                 sipc_util_marshal_object_add_data(out_obj, "result", &result, SIPC_MARSHAL_DATA_BOOLEAN_TYPE);
 654                                 sipc_util_marshal_object_add_data(out_obj, "err_cause", &err_cause, SIPC_MARSHAL_DATA_BOOLEAN_INT);
 655                                 .......
 656                         */
 657
 658                         //TAPI_EVENT_CLASS_CALL_VOICE,
 659                         //TAPI_EVENT_CALL_ALERT_IND,
 660                         break;
 661
 662                 case TNOTI_CALL_STATUS_ACTIVE:
 663
 664                         /*{create output data and create serialized data}
 665                                 hdr->cmd = ;
 666                                 out_obj = sipc_util_marshal_object_create();
 667                                 sipc_util_marshal_object_add_data(out_obj, "result", &result, SIPC_MARSHAL_DATA_BOOLEAN_TYPE);
 668                                 sipc_util_marshal_object_add_data(out_obj, "err_cause", &err_cause, SIPC_MARSHAL_DATA_BOOLEAN_INT);
 669                                 .......
 670                         */
 671
 672                         //TAPI_EVENT_CLASS_CALL_VOICE,
 673                         //TAPI_EVENT_CALL_CONNECTED_IND,
 674                         break;
 675
 676                 case TNOTI_CALL_STATUS_HELD:
 677
 678                         /*{create output data and create serialized data}
 679                                 hdr->cmd = ;
 680                                 out_obj = sipc_util_marshal_object_create();
 681                                 sipc_util_marshal_object_add_data(out_obj, "result", &result, SIPC_MARSHAL_DATA_BOOLEAN_TYPE);
 682                                 sipc_util_marshal_object_add_data(out_obj, "err_cause", &err_cause, SIPC_MARSHAL_DATA_BOOLEAN_INT);
 683                                 .......
 684                         */
 685
 686                         //TAPI_EVENT_CLASS_CALL_VOICE,
 687                         //TAPI_EVENT_CALL_HOLD_IND,
 688                         break;
 689
 690                 case TNOTI_CALL_STATUS_INCOMING: {
 691                         struct tnoti_call_status_incoming *incoming = 0;
 692                         char id[2] = {0, };
 693                         char cli[2] = {0, };
 694                         char forward[2] = {0, };
 695                         char active_line[2] = {0, };
 696                         char cna[2] = {0, };
 697                         char number[83] = {0, };
 698                         char name[83] = {0, };
 699                         int ret = 0;
 700
 701                         bundle *kb  = 0;
 702
 703                         incoming = (struct tnoti_call_status_incoming*)data;
 704
 705                         snprintf( id, 2, "%d", incoming->id );
 706                         dbg("id : [%s]", id );
 707                         snprintf( cli, 2, "%d", incoming->cli.mode );
 708                         dbg("cli : [%s]", id );
 709                         snprintf( number, 83, "%s", incoming->cli.number );
 710                         dbg("number : [%s]", number );
 711                         snprintf( forward, 2, "%d", incoming->forward );
 712                         dbg("forward : [%s]", forward );
 713                         snprintf( active_line, 2, "%d", incoming->active_line );
 714                         dbg("active_line : [%s]", active_line );
 715                         snprintf( cna, 2, "%d", incoming->cna.mode );
 716                         dbg("cna : [%s]", cna );
 717                         snprintf( name, 83, "%s", incoming->cna.name );
 718                         dbg("name : [%s]", name );
 719
 720                         kb = bundle_create();
 721                         bundle_add(kb, "launch-type", "MT");
 722                         bundle_add(kb, "handle", id);
 723                         bundle_add(kb, "number", number);
 724                         bundle_add(kb, "name_mode", cna);
 725                         bundle_add(kb, "name", name);
 726                         bundle_add(kb, "clicause", cli);
 727                         bundle_add(kb, "fwded", forward);
 728                         bundle_add(kb, "activeline", active_line);
 729
 730                         ret = aul_launch_app("com.samsung.call", kb);
 731                         bundle_free(kb);
 732
 733                         dbg("aul_launch_app [ voice call ] : %d", ret);
 734                         return TRUE;
 735                 }
 736                         break;
 737
 738                 case TNOTI_CALL_STATUS_WAITING:
 739                 default:
 740                         break;
 741         }
 742
 743         if(out_obj){
 744                 serial_d = sipc_util_marshal_object_serializer(out_obj);
 745                 hdr.data_len = strlen(serial_d);
 746                 sipc_util_marshal_object_destory(out_obj);
 747         }
 748
 749         out_d = g_new0(char, sizeof(struct _tapi_header)+hdr.data_len);
 750         memcpy(out_d, &hdr, sizeof(struct _tapi_header));
 751         if(serial_d){
 752                 memcpy(out_d+sizeof(struct _tapi_header), serial_d, hdr.data_len);
 753                 g_free(serial_d);
 754         }
 755
 756         ret = sipc_server_broadcast(s, out_d, sizeof(struct _tapi_header)+hdr.data_len);
 757         g_free(out_d);
 758
 759         if(ret < 0){
 760                 return FALSE;
 761         }
 762
 763         return TRUE;
 764 }