src/sat_manager.c

   1 /*
   2  * tel-plugin-dbus-tapi
   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 #include <stdio.h>
  21 #include <string.h>
  22 #include <stdlib.h>
  23 #include <errno.h>
  24 #include <sys/time.h>
  25
  26 #include <tcore.h>
  27 #include <server.h>
  28 #include <plugin.h>
  29 #include <storage.h>
  30 #include <hal.h>
  31 #include <communicator.h>
  32 #include <core_object.h>
  33 #include <queue.h>
  34 #include <user_request.h>
  35 #include <util.h>
  36 #include <co_sat.h>
  37 #include <co_call.h>
  38 #include <co_network.h>
  39 #include <type/call.h>
  40 #include <type/sim.h>
  41
  42 #include <libxml/xmlmemory.h>
  43 #include <libxml/parser.h>
  44 #include <libxml/tree.h>
  45
  46 #include "generated-code.h"
  47 #include "common.h"
  48 #include "sat_manager.h"
  49 #include "sat_ui_support/sat_ui_support.h"
  50
  51 #define SAT_DEF_CMD_Q_MAX 10
  52 #define SAT_DEF_CMD_Q_MIN 0
  53 #define SAT_TIME_OUT 30000
  54 #define TIZEN_SAT_DELAY_TO_CLEAN_MSG 15000
  55 #define SAT_USC2_INPUT_LEN_MAX 70
  56 #define SAT_EVENT_DOWNLOAD_MAX 9
  57
  58 #define LANGUAGE_XML_PATH "/opt/usr/apps/org.tizen.setting/data/langlist.xml"
  59
  60 #define SAT_CMD_Q_CHECK(index) \
  61         if (index < SAT_DEF_CMD_Q_MIN || index > SAT_DEF_CMD_Q_MAX-1) { warn("invalid index!!"); return FALSE; }
  62
  63 static gboolean _sat_manager_handle_open_channel_confirm(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gint confirm_type, GVariant *addtional_data);
  64
  65 static struct sat_manager_queue_data *sat_queue[SAT_DEF_CMD_Q_MAX] = {NULL, };
  66 gboolean g_evt_list[SAT_EVENT_DOWNLOAD_MAX] = {0};
  67
  68 static unsigned char _convert_decimal_to_bcd(int dec)
  69 {
  70         int tmp1, tmp0;
  71         unsigned char tmp3;
  72
  73         tmp1 = dec/10;
  74         tmp0 = dec - tmp1*10;
  75         tmp3 = tmp0 << 4;
  76         tmp3 += tmp1;
  77
  78         dbg("input decimal(%d), bcd(%d%d), endian(%x)", dec, tmp1, tmp0, tmp3);
  79         return tmp3;
  80 }
  81
  82 static const gchar* _convert_sim_lang_to_string(enum tel_sim_language_type lang)
  83 {
  84         dbg("convert lang(%d)", lang);
  85         switch(lang){
  86                 case SIM_LANG_GERMAN:
  87                         return "de_DE.UTF-8";
  88                 case SIM_LANG_ENGLISH:
  89                         return "en_GB.UTF-8";
  90                 case SIM_LANG_ITALIAN:
  91                         return "it_IT.UTF-8";
  92                 case SIM_LANG_FRENCH:
  93                         return "fr_FR.UTF-8";
  94                 case SIM_LANG_SPANISH:
  95                         return "es_ES.UTF-8";
  96                 case SIM_LANG_DUTCH:
  97                         return "nl_NL.UTF-8";
  98                 case SIM_LANG_SWEDISH:
  99                         return "sv_SE.UTF-8";
 100                 case SIM_LANG_DANISH:
 101                         return "da_DK.UTF-8";
 102                 case SIM_LANG_PORTUGUESE:
 103                         return "pt_PT.UTF-8";
 104                 case SIM_LANG_FINNISH:
 105                         return "fi_FI.UTF-8";
 106                 case SIM_LANG_NORWEGIAN:
 107                         return "nb_NO.UTF-8";
 108                 case SIM_LANG_GREEK:
 109                         return "el_GR.UTF-8";
 110                 case SIM_LANG_TURKISH:
 111                         return "tr_TR.UTF-8";
 112                 case SIM_LANG_HUNGARIAN:
 113                         return "hu_HU.UTF-8";
 114                 case SIM_LANG_POLISH:
 115                         return "pl_PL.UTF-8";
 116                 case SIM_LANG_KOREAN:
 117                         return "ko_KR.UTF-8";
 118                 case SIM_LANG_CHINESE:
 119                         return "zh_CH.UTF-8";
 120                 case SIM_LANG_RUSSIAN:
 121                         return "ru_RU.UTF-8";
 122                 case SIM_LANG_JAPANESE:
 123                         return "ja_JP.UTF-8";
 124                 default:
 125                         return NULL;
 126         }//end of switch
 127
 128         return NULL;
 129 }
 130
 131 static enum tel_sim_language_type _convert_string_to_sim_lang(const gchar* lang_str)
 132 {
 133         dbg("convert lang(%s)", lang_str);
 134
 135         if (g_str_equal(lang_str, "de_DE.UTF-8") == TRUE) {
 136                 return SIM_LANG_GERMAN;
 137         }
 138         else if (g_str_equal(lang_str, "en_GB.UTF-8") == TRUE) {
 139                 return SIM_LANG_ENGLISH;
 140         }
 141         else if (g_str_equal(lang_str, "it_IT.UTF-8") == TRUE) {
 142                 return SIM_LANG_ITALIAN;
 143         }
 144         else if (g_str_equal(lang_str, "fr_FR.UTF-8") == TRUE) {
 145                 return SIM_LANG_FRENCH;
 146         }
 147         else if (g_str_equal(lang_str, "es_ES.UTF-8") == TRUE) {
 148                 return SIM_LANG_SPANISH;
 149         }
 150         else if (g_str_equal(lang_str, "nl_NL.UTF-8") == TRUE) {
 151                 return SIM_LANG_DUTCH;
 152         }
 153         else if (g_str_equal(lang_str, "sv_SE.UTF-8") == TRUE) {
 154                 return SIM_LANG_SWEDISH;
 155         }
 156         else if (g_str_equal(lang_str, "da_DK.UTF-8") == TRUE) {
 157                 return SIM_LANG_DANISH;
 158         }
 159         else if (g_str_equal(lang_str, "pt_PT.UTF-8") == TRUE) {
 160                 return SIM_LANG_PORTUGUESE;
 161         }
 162         else if (g_str_equal(lang_str, "fi_FI.UTF-8") == TRUE) {
 163                 return SIM_LANG_FINNISH;
 164         }
 165         else if (g_str_equal(lang_str, "nb_NO.UTF-8") == TRUE) {
 166                 return SIM_LANG_NORWEGIAN;
 167         }
 168         else if (g_str_equal(lang_str, "el_GR.UTF-8") == TRUE) {
 169                 return SIM_LANG_GREEK;
 170         }
 171         else if (g_str_equal(lang_str, "tr_TR.UTF-8") == TRUE) {
 172                 return SIM_LANG_TURKISH;
 173         }
 174         else if (g_str_equal(lang_str, "hu_HU.UTF-8") == TRUE) {
 175                 return SIM_LANG_HUNGARIAN;
 176         }
 177         else if (g_str_equal(lang_str, "pl_PL.UTF-8") == TRUE) {
 178                 return SIM_LANG_POLISH;
 179         }
 180         else if (g_str_equal(lang_str, "ko_KR.UTF-8") == TRUE) {
 181                 return SIM_LANG_KOREAN;
 182         }
 183         else if (g_str_equal(lang_str, "zh_CH.UTF-8") == TRUE) {
 184                 return SIM_LANG_CHINESE;
 185         }
 186         else if (g_str_equal(lang_str, "ru_RU.UTF-8") == TRUE) {
 187                 return SIM_LANG_RUSSIAN;
 188         }
 189         else if (g_str_equal(lang_str, "ja_JP.UTF-8") == TRUE) {
 190                 return SIM_LANG_JAPANESE;
 191         }
 192
 193         dbg("there is no matched language");
 194         return SIM_LANG_UNSPECIFIED;
 195 }
 196
 197 static unsigned char _convert_hex_char_to_int(char c)
 198 {
 199         if (c >= '0' && c <= '9')
 200                 return (c - '0');
 201         else if (c >= 'A' && c <= 'F')
 202                 return (c - 'A' + 10);
 203         else if (c >= 'a' && c <= 'f')
 204                 return (c - 'a' + 10);
 205         else {
 206                 dbg("invalid charater!!");
 207                 return -1;
 208         }
 209 }
 210
 211 static char* _convert_hex_string_to_bytes(char *s)
 212 {
 213         char *ret;
 214         int i;
 215         int sz;
 216
 217         if (s == NULL)
 218                 return NULL;
 219
 220         sz = strlen(s);
 221         ret = calloc(1, (sz / 2) + 1);
 222         if (ret == NULL)
 223                 return NULL;
 224
 225         dbg("Convert String to Binary!!");
 226
 227         for (i = 0; i < sz; i += 2) {
 228                 ret[i / 2] = (char) ((_convert_hex_char_to_int(s[i]) << 4) | _convert_hex_char_to_int(s[i + 1]));
 229         }
 230
 231         return ret;
 232 }
 233
 234 static unsigned int _get_time_in_ms(struct tel_sat_duration *dr)
 235 {
 236         switch (dr->time_unit) {
 237                 case TIME_UNIT_MINUTES:
 238                         return (unsigned int)dr->time_interval * 60000;
 239                         break;
 240
 241                 case TIME_UNIT_SECONDS:
 242                         return (unsigned int)dr->time_interval * 1000;
 243                         break;
 244
 245                 case TIME_UNIT_TENTHS_OF_SECONDS:
 246                         return (unsigned int)dr->time_interval * 100;
 247                         break;
 248
 249                 case TIME_UNIT_RESERVED:
 250                 default:
 251                         return 0;       // set default
 252                         break;
 253         }
 254
 255         return 0;
 256 }
 257
 258 static int _get_queue_empty_index(void)
 259 {
 260         int cnt = 0;
 261         int i;
 262         int local_index = -1;
 263
 264         for(i =0; i<SAT_DEF_CMD_Q_MAX ; i++) {
 265                 if(sat_queue[i]) {
 266                         dbg("index[%d] is being used",i);
 267                         cnt++;
 268                 }
 269         }
 270         for(i =0; i<SAT_DEF_CMD_Q_MAX ; i++) {
 271                 if(!sat_queue[i]) {
 272                         dbg("found empty slot [%p] at index [%d]", sat_queue[i] ,i);
 273                         local_index = i;
 274                         break;
 275                 }
 276         }
 277         dbg("[SAT]SAT Command Queue current length [%d], MAX [%d]. \n", cnt, SAT_DEF_CMD_Q_MAX);
 278         return local_index;
 279 }
 280
 281 static gboolean _push_data(struct custom_data *ctx, struct sat_manager_queue_data *cmd_obj)
 282 {
 283         struct sat_manager_queue_data *item;
 284         int local_index = cmd_obj->cmd_id;
 285
 286         SAT_CMD_Q_CHECK(local_index);
 287
 288         if (sat_queue[local_index]) {
 289                 dbg("[SAT] sat_queue[%d] is not null [%p].\n", sat_queue[local_index]);
 290                 return FALSE;
 291         }
 292
 293         item = g_new0(struct sat_manager_queue_data, 1);
 294
 295         if(!item) {
 296                 dbg("[SAT] FAILED TO ALLOC QUEUE ITEM!\n");
 297                 return FALSE;
 298         }
 299
 300         memcpy((void*)item, (void*)cmd_obj, sizeof(struct sat_manager_queue_data));
 301         sat_queue[local_index] = item;
 302         dbg("push data to queue at index[%d], [%p].\n",local_index, item);
 303         return TRUE;
 304 }
 305
 306 static gboolean _pop_nth_data(struct custom_data *ctx, struct sat_manager_queue_data *cmd_obj, int command_id)
 307 {
 308         struct sat_manager_queue_data *item;
 309         int local_index = command_id;
 310
 311         SAT_CMD_Q_CHECK(local_index);
 312
 313         if(!sat_queue[local_index]) {
 314                 dbg("[SAT] sat_queue[%d] is null !!\n", local_index);
 315                 return FALSE;
 316         }
 317
 318         item = sat_queue[local_index];
 319
 320         memcpy((void*)cmd_obj, (void*)item, sizeof(struct sat_manager_queue_data));
 321         dbg("pop data from queue at index[%d],[%p].\n",local_index, item);
 322         sat_queue[local_index] = NULL;
 323         g_free(item);
 324         return TRUE;
 325 }
 326
 327 static gboolean _peek_nth_data(struct custom_data *ctx, struct sat_manager_queue_data *cmd_obj, int command_id)
 328 {
 329         struct sat_manager_queue_data *item = NULL;
 330
 331         int local_index = command_id;
 332
 333         SAT_CMD_Q_CHECK(local_index);
 334
 335         if(!sat_queue[local_index]) {
 336                 dbg("[SAT] sat_queue[%d] is null !!\n", local_index);
 337                 return FALSE;
 338         }
 339
 340         item = sat_queue[local_index];
 341         memcpy((void*)cmd_obj, (void*)item, sizeof(struct sat_manager_queue_data));
 342         dbg("peek data from queue at index[%d],[%p].\n",local_index, item);
 343         return TRUE;
 344 }
 345
 346 static gboolean _sat_manager_check_language_set(const char* lan)
 347 {
 348         xmlNode *cur_node = NULL;
 349         xmlNodePtr cur;
 350         void *xml_doc = NULL,*xml_root_node = NULL;
 351         char *id = NULL;
 352         gboolean ret = FALSE;
 353
 354         dbus_plugin_util_load_xml(LANGUAGE_XML_PATH, "langlist", &xml_doc, &xml_root_node);
 355         if (!xml_root_node) {
 356                 err("[LANGUAGE LIST] Load error - Root node is NULL.");
 357                 goto EXIT;
 358         }
 359
 360         cur = xml_root_node;
 361         /* Compare language */
 362         for(cur_node = cur; cur_node; cur_node = cur_node->next) {
 363                 if (cur_node->type == XML_ELEMENT_NODE) {
 364                         id = (char *)xmlGetProp(cur_node, (const xmlChar *)"id");
 365                         if (id && g_str_has_prefix(lan, id)) {
 366                                 dbg("Supported: id[%s], lan[%s]", id, lan);
 367                                 ret = TRUE;
 368                                 goto EXIT;
 369                         }
 370                 }
 371         }
 372         warn("Not supported language[%s]", lan);
 373 EXIT:
 374         dbus_plugin_util_unload_xml(&xml_doc, &xml_root_node);
 375         return ret;
 376 }
 377
 378 void sat_manager_init_queue(struct custom_data *ctx, const char *cp_name)
 379 {
 380         int i;
 381
 382         dbg("Entered into queue");
 383         for(i=0;i<SAT_DEF_CMD_Q_MAX;i++) {
 384                 struct sat_manager_queue_data * item = sat_queue[i];
 385                 if(item != NULL && !g_strcmp0(cp_name,item->cp_name)) {
 386                         dbg("item[%d]: cmd_type[%d]", i, item->cmd_type);
 387 #if defined(TIZEN_PLATFORM_USE_QCOM_QMI)
 388                         switch(item->cmd_type) {
 389                                 case SAT_PROATV_CMD_SEND_SMS:
 390                                 case SAT_PROATV_CMD_SEND_SS:
 391                                 case SAT_PROATV_CMD_SEND_USSD:
 392                                 case SAT_PROATV_CMD_SEND_DTMF: {
 393                                         dbg("[SAT] set noti flag");
 394                                         item->noti_required = TRUE;
 395                                         return;
 396                                         } break;
 397                                 default:
 398                                         break;
 399                         }
 400 #endif
 401                         g_free(item->cp_name);
 402                         g_free(item);
 403                         sat_queue[i] = NULL;
 404                 }
 405         }
 406 }
 407
 408 static gboolean sat_manager_enqueue_cmd(struct custom_data *ctx, struct sat_manager_queue_data *cmd_obj)
 409 {
 410         int id;
 411
 412         id = _get_queue_empty_index();
 413         if(id < 0) {
 414                 dbg("Fail to get empty index.\n");
 415                 return FALSE;
 416         }
 417         cmd_obj->cmd_id = id;
 418         return _push_data(ctx, cmd_obj);
 419 }
 420
 421 static gboolean sat_manager_dequeue_cmd_by_id(struct custom_data *ctx, struct sat_manager_queue_data *cmd_obj, int cmd_id)
 422 {
 423         return _pop_nth_data(ctx, cmd_obj, cmd_id);
 424 }
 425
 426 static gboolean sat_manager_queue_peek_data_by_id(struct custom_data *ctx, struct sat_manager_queue_data *cmd_obj, int command_id)
 427 {
 428         return _peek_nth_data(ctx, cmd_obj, command_id);
 429 }
 430
 431 static gboolean sat_manager_check_availiable_event_list(struct tel_sat_setup_event_list_tlv *event_list_tlv)
 432 {
 433         gboolean rv = TRUE;
 434         int local_index = 0;
 435
 436         for(local_index = 0; local_index < event_list_tlv->event_list.event_list_cnt; local_index++){
 437                 if(event_list_tlv->event_list.evt_list[local_index] == EVENT_USER_ACTIVITY){
 438                         dbg("do user activity");
 439                 }
 440                 else if(event_list_tlv->event_list.evt_list[local_index] == EVENT_IDLE_SCREEN_AVAILABLE){
 441                         dbg("do idle screen");
 442                 }
 443                 else if(event_list_tlv->event_list.evt_list[local_index] == EVENT_LANGUAGE_SELECTION){
 444                         dbg("do language selection");
 445                 }
 446                 else if(event_list_tlv->event_list.evt_list[local_index] == EVENT_BROWSER_TERMINATION){
 447                         dbg("do browser termination");
 448                 }
 449                 else if(event_list_tlv->event_list.evt_list[local_index] == EVENT_DATA_AVAILABLE){
 450                         dbg("do data available (bip)");
 451                 }
 452                 else if(event_list_tlv->event_list.evt_list[local_index] == EVENT_CHANNEL_STATUS){
 453                         dbg("do channel status (bip)");
 454                 }
 455                 else{
 456                         dbg("unmanaged event (%d)", event_list_tlv->event_list.evt_list[local_index]);
 457                         rv = FALSE;
 458                 }
 459         }
 460
 461         return rv;
 462 }
 463
 464 #if defined(TIZEN_PLATFORM_USE_QCOM_QMI)
 465 static TReturn sat_manager_send_user_confirmation(Communicator *comm, TcorePlugin *target_plg, struct treq_sat_user_confirmation_data *conf_data)
 466 {
 467         TReturn rv = TCORE_RETURN_SUCCESS;
 468         UserRequest *ur = NULL;
 469
 470         ur = tcore_user_request_new(comm, tcore_server_get_cp_name_by_plugin(target_plg));
 471         if (!ur) {
 472                 dbg("ur is NULL");
 473                 return TCORE_RETURN_FAILURE;
 474         }
 475
 476         tcore_user_request_set_command(ur, TREQ_SAT_REQ_USERCONFIRMATION);
 477         tcore_user_request_set_data(ur, sizeof(struct treq_sat_user_confirmation_data), (void *)conf_data);
 478         rv = tcore_communicator_dispatch_request(comm, ur);
 479         if (rv != TCORE_RETURN_SUCCESS) {
 480                 dbg("fail to send terminal response",rv);
 481                 tcore_user_request_unref(ur);
 482                 rv = TCORE_RETURN_FAILURE;
 483         }
 484
 485         return rv;
 486 }
 487 #endif
 488
 489 static TReturn sat_manager_send_terminal_response(Communicator *comm, TcorePlugin *target_plg, struct treq_sat_terminal_rsp_data *tr)
 490 {
 491         TReturn rv = TCORE_RETURN_SUCCESS;
 492         UserRequest *ur = NULL;
 493
 494         ur = tcore_user_request_new(comm, tcore_server_get_cp_name_by_plugin(target_plg));
 495         if (!ur) {
 496                 dbg("ur is NULL");
 497                 return TCORE_RETURN_FAILURE;
 498         }
 499
 500         tcore_user_request_set_command(ur, TREQ_SAT_REQ_TERMINALRESPONSE);
 501         tcore_user_request_set_data(ur, sizeof(struct treq_sat_terminal_rsp_data), (void *)tr);
 502         rv = tcore_communicator_dispatch_request(comm, ur);
 503         if (rv != TCORE_RETURN_SUCCESS) {
 504                 dbg("fail to send terminal response",rv);
 505                 tcore_user_request_unref(ur);
 506                 rv = TCORE_RETURN_FAILURE;
 507         }
 508
 509         return rv;
 510 }
 511
 512 gboolean sat_manager_remove_cmd_by_id(struct custom_data *ctx, int cmd_id)
 513 {
 514         struct sat_manager_queue_data *item;
 515         int local_index = cmd_id;
 516
 517         if(!sat_queue[local_index]) {
 518                 dbg("[SAT] sat_queue[%d] is already null !!\n", local_index);
 519                 return FALSE;
 520         }
 521         item = sat_queue[local_index];
 522
 523         dbg("remove data from queue at index[%d],[%p].\n",local_index, item);
 524         sat_queue[local_index] = NULL;
 525         g_free(item->cp_name);
 526         g_free(item);
 527         return TRUE;
 528 }
 529
 530 GVariant* sat_manager_caching_setup_menu_info(struct custom_data *ctx, const char *cp_name, struct tel_sat_setup_menu_tlv* setup_menu_tlv)
 531 {
 532         TcorePlugin *plg = NULL;
 533         GVariant *setup_menu_info = NULL;
 534         struct sat_manager_queue_data q_data;
 535
 536         gushort title_len = 0;
 537         gint command_id = 0, menu_cnt = 0;
 538         gboolean menu_present = FALSE, help_info = FALSE, updated = FALSE;
 539         gchar main_title[SAT_ALPHA_ID_LEN_MAX];
 540         GVariantBuilder v_builder;
 541         GVariant *menu_items = NULL;
 542 #if defined(TIZEN_SUPPORT_SAT_ICON)
 543         int local_index = 0;
 544         GVariant *icon_id = NULL;
 545         GVariant *icon_list = NULL;
 546         GVariant *icon_list_info = NULL;
 547         GVariantBuilder v_builder_icon;
 548         GVariantBuilder v_builder_icon_list_data;
 549 #endif
 550         /* To check menu update */
 551         GSList *list = NULL;
 552         struct cached_data *object;
 553         struct treq_sat_terminal_rsp_data tr;
 554
 555         dbg("interpreting setup menu notification");
 556         memset(&main_title, 0 , SAT_ALPHA_ID_LEN_MAX);
 557
 558         plg = tcore_server_find_plugin(ctx->server, cp_name);
 559         if (!plg){
 560                 dbg("there is no valid plugin at this point");
 561                 return NULL;
 562         }
 563
 564         /* check menu info is already updated */
 565         for (list = ctx->cached_data; list; list = list->next) {
 566                 object = (struct cached_data *) list->data;
 567                 if (object == NULL)
 568                         continue;
 569
 570                 if (g_strcmp0(object->cp_name, cp_name) == 0) {
 571                         if(object->cached_sat_main_menu) {
 572                                 dbg("main menu info is updated");
 573                                 updated = TRUE;
 574                         }
 575                 }
 576         }
 577
 578         //check the validation of content
 579         if(!setup_menu_tlv->menu_item_cnt || !setup_menu_tlv->menu_item[0].text_len){
 580                 //support GCF case 27.22.4.8.1 - 1.1 setup menu
 581
 582                 dbg("no menu item updated menu(%d)", updated);
 583
 584                 memset(&tr, 0, sizeof(struct treq_sat_terminal_rsp_data));
 585                 tr.cmd_number = setup_menu_tlv->command_detail.cmd_num;
 586                 tr.cmd_type = setup_menu_tlv->command_detail.cmd_type;
 587
 588                 memcpy((void*)&tr.terminal_rsp_data.setup_menu.command_detail,
 589                                 &setup_menu_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
 590                 tr.terminal_rsp_data.setup_menu.device_id.src = setup_menu_tlv->device_id.dest;
 591                 tr.terminal_rsp_data.setup_menu.device_id.dest = setup_menu_tlv->device_id.src;
 592
 593                 if(updated){
 594                         tr.terminal_rsp_data.setup_menu.result_type = RESULT_SUCCESS;
 595                 }else{
 596                         tr.terminal_rsp_data.setup_menu.result_type = RESULT_BEYOND_ME_CAPABILITIES;
 597                 }
 598
 599                 sat_manager_send_terminal_response(ctx->comm, plg, &tr);
 600                 //return NULL;
 601         }
 602
 603
 604         help_info = setup_menu_tlv->command_detail.cmd_qualifier.setup_menu.help_info;
 605         menu_present = setup_menu_tlv->command_detail.cmd_qualifier.setup_menu.select_preference;
 606         menu_cnt = setup_menu_tlv->menu_item_cnt;
 607
 608         //get title
 609         if(setup_menu_tlv->alpha_id.alpha_data_len)
 610                 tcore_util_convert_string_to_utf8((unsigned char*)&main_title, (unsigned short*)&title_len,
 611                         setup_menu_tlv->alpha_id.dcs.a_format,
 612                         (unsigned char*)&setup_menu_tlv->alpha_id.alpha_data,
 613                         (unsigned short)setup_menu_tlv->alpha_id.alpha_data_len);
 614         dbg("sat main menu title(%s)",main_title);
 615
 616         g_variant_builder_init(&v_builder, G_VARIANT_TYPE ("a(si)"));
 617
 618         //get menu items
 619         if(!setup_menu_tlv->next_act_ind_list.cnt){
 620                 int local_index = 0;
 621
 622                 dbg("setup_menu_tlv->next_act_ind_list.cnt == 0");
 623
 624                 for(local_index = 0; local_index < menu_cnt; local_index++){
 625                         gushort item_len;
 626                         gchar item_str[SAT_ITEM_TEXT_LEN_MAX + 1];
 627
 628                         memset(&item_str, 0 , SAT_ITEM_TEXT_LEN_MAX + 1);
 629                         tcore_util_convert_string_to_utf8((unsigned char*)&item_str, (unsigned short *)&item_len,
 630                                 setup_menu_tlv->menu_item[local_index].dcs.a_format,
 631                                 (unsigned char*)&setup_menu_tlv->menu_item[local_index].text,
 632                                 (unsigned short)setup_menu_tlv->menu_item[local_index].text_len);
 633
 634                         dbg( "index(%d) item_id(%d) item_string(%s)", local_index, setup_menu_tlv->menu_item[local_index].item_id, item_str);
 635
 636                         //g_variant_builder_add(v_builder, "(sy)", &item_str, setup_menu_tlv->menu_item[index].item_id);
 637                         g_variant_builder_add(&v_builder, "(si)", item_str, (gint32)(setup_menu_tlv->menu_item[local_index].item_id));
 638                 }
 639         }
 640         else{
 641                 int local_index = 0;
 642
 643                 dbg("setup_menu_tlv->next_act_ind_list.cnt != 0");
 644
 645                 for(local_index = 0; local_index < menu_cnt; local_index++){
 646                         gushort item_len;
 647                         gchar item_str[SAT_ITEM_TEXT_LEN_MAX + 1];
 648
 649                         memset(&item_str, '\0' , SAT_ITEM_TEXT_LEN_MAX + 1);
 650                         tcore_util_convert_string_to_utf8((unsigned char*)&item_str, (unsigned short *)&item_len,
 651                                 setup_menu_tlv->menu_item[local_index].dcs.a_format,
 652                                 (unsigned char*)&setup_menu_tlv->menu_item[local_index].text,
 653                                 (unsigned short)setup_menu_tlv->menu_item[local_index].text_len);
 654
 655                         dbg( "index(%d) item_id(%d) item_string(%s)", local_index, setup_menu_tlv->menu_item[local_index].item_id, item_str);
 656
 657                         //g_variant_builder_add(v_builder, "(sy)", g_strdup(item_str), setup_menu_tlv->menu_item[local_index].item_id);
 658                         g_variant_builder_add(&v_builder, "(si)", item_str, (gint32)(setup_menu_tlv->menu_item[local_index].item_id));
 659                 }
 660         }
 661
 662         menu_items = g_variant_builder_end(&v_builder);
 663
 664         //enqueue data and generate cmd_id
 665         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
 666         q_data.cmd_type = SAT_PROATV_CMD_SETUP_MENU;
 667         q_data.cp_name = g_strdup(cp_name);
 668         memcpy((void*)&(q_data.cmd_data.setupMenuInd), setup_menu_tlv, sizeof(struct tel_sat_setup_menu_tlv));
 669         if(FALSE == sat_manager_enqueue_cmd(ctx, &q_data)){
 670                 g_free(q_data.cp_name);
 671         }
 672         command_id = q_data.cmd_id;
 673
 674 #if defined(TIZEN_SUPPORT_SAT_ICON)
 675         /* Icon data extraction */
 676         g_variant_builder_init(&v_builder_icon, G_VARIANT_TYPE ("a(biiiiiis)"));
 677         if(setup_menu_tlv->icon_id.is_exist) {
 678                 g_variant_builder_add(&v_builder_icon, "(biiiiiis)", setup_menu_tlv->icon_id.is_exist, setup_menu_tlv->icon_id.icon_qualifer, (gint32) setup_menu_tlv->icon_id.icon_identifier, (gint32) setup_menu_tlv->icon_id.icon_info.width,
 679                         (gint32) setup_menu_tlv->icon_id.icon_info.height, setup_menu_tlv->icon_id.icon_info.ics, setup_menu_tlv->icon_id.icon_info.icon_data_len, setup_menu_tlv->icon_id.icon_info.icon_file);
 680         }
 681         icon_id = g_variant_builder_end(&v_builder_icon);
 682
 683         /* Icon list data extraction */
 684         g_variant_builder_init(&v_builder_icon, G_VARIANT_TYPE ("a(biiv)"));
 685         if(setup_menu_tlv->icon_list.is_exist) {
 686                 g_variant_builder_init(&v_builder_icon_list_data, G_VARIANT_TYPE ("a(iiiiis)"));
 687                 for(local_index= 0; local_index< (int)setup_menu_tlv->icon_list.icon_cnt; local_index++){
 688                         g_variant_builder_add(&v_builder_icon_list_data, "(iiiiis)", (gint32) setup_menu_tlv->icon_list.icon_id_list[local_index], (gint32) setup_menu_tlv->icon_list.icon_info[local_index].width,
 689                                 (gint32) setup_menu_tlv->icon_list.icon_info[local_index].height, setup_menu_tlv->icon_list.icon_info[local_index].ics, setup_menu_tlv->icon_list.icon_info[local_index].icon_data_len, setup_menu_tlv->icon_list.icon_info[local_index].icon_file);
 690                 }
 691                 icon_list_info = g_variant_builder_end(&v_builder_icon_list_data);
 692
 693                 g_variant_builder_add(&v_builder_icon, "(biiv)", setup_menu_tlv->icon_list.is_exist, setup_menu_tlv->icon_list.icon_qualifer, (gint32) setup_menu_tlv->icon_list.icon_cnt, icon_list_info);
 694         }
 695         icon_list = g_variant_builder_end(&v_builder_icon);
 696
 697         setup_menu_info = g_variant_new("(ibsvibbvv)", command_id, menu_present, main_title, menu_items,
 698                         menu_cnt, help_info, updated, icon_id, icon_list);
 699 #else
 700         setup_menu_info = g_variant_new("(ibsvibb)", command_id, menu_present, main_title, menu_items,
 701                         menu_cnt, help_info, updated);
 702 #endif
 703         return setup_menu_info;
 704 }
 705
 706 GVariant* sat_manager_display_text_noti(struct custom_data *ctx, const char *cp_name, struct tel_sat_display_text_tlv* display_text_tlv, int decode_error)
 707 {
 708         TcorePlugin *plg = NULL;
 709         GVariant *display_text = NULL;
 710         struct sat_manager_queue_data q_data;
 711
 712         gushort text_len = 0;
 713         gint command_id = 0, duration= 0, tmp_duration = 0;
 714         gboolean immediately_rsp = FALSE, high_priority = FALSE, user_rsp_required = FALSE;
 715         gchar text[SAT_TEXT_STRING_LEN_MAX+1];
 716 #if defined(TIZEN_SUPPORT_SAT_ICON)
 717         GVariant *icon_id = NULL;
 718         GVariantBuilder v_builder_icon;
 719 #endif
 720         dbg("interpreting display text notification");
 721         memset(&text, 0 , SAT_TEXT_STRING_LEN_MAX+1);
 722
 723         plg = tcore_server_find_plugin(ctx->server, cp_name);
 724         if (!plg){
 725                 dbg("there is no valid plugin at this point");
 726                 return NULL;
 727         }
 728
 729         if(!display_text_tlv->text.string_length ||
 730                 (display_text_tlv->text.string_length > 0 && decode_error != TCORE_SAT_SUCCESS)){
 731                 struct treq_sat_terminal_rsp_data tr;
 732
 733                 dbg("displat text - invalid parameter of TLVs is found!!");
 734
 735                 memset(&tr, 0, sizeof(struct treq_sat_terminal_rsp_data));
 736                 tr.cmd_number = display_text_tlv->command_detail.cmd_num;
 737                 tr.cmd_type = display_text_tlv->command_detail.cmd_type;
 738
 739                 memcpy((void*) &tr.terminal_rsp_data.display_text.command_detail,
 740                         &display_text_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
 741
 742                 tr.terminal_rsp_data.display_text.device_id.src = DEVICE_ID_ME;
 743                 tr.terminal_rsp_data.display_text.device_id.dest = DEVICE_ID_SIM;
 744                 tr.terminal_rsp_data.display_text.result_type = RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME;
 745
 746                 sat_manager_send_terminal_response(ctx->comm, plg, &tr);
 747
 748                 return NULL;
 749         }
 750
 751         //user resp required & time_duration
 752         if(display_text_tlv->command_detail.cmd_qualifier.display_text.text_clear_type == TEXT_WAIT_FOR_USER_TO_CLEAR_MSG){
 753                 user_rsp_required = TRUE;
 754                 duration = SAT_TIME_OUT;
 755         }
 756         else{
 757                 /* Set by default if duration is not provided. */
 758                 duration = TIZEN_SAT_DELAY_TO_CLEAN_MSG;
 759         }
 760
 761         //immediate response requested
 762         if (display_text_tlv->immediate_response_requested)
 763                 immediately_rsp = TRUE;
 764
 765         //high priority
 766         if (display_text_tlv->command_detail.cmd_qualifier.display_text.text_priority == TEXT_PRIORITY_HIGH)
 767                 high_priority = TRUE;
 768
 769         //get text
 770         tcore_util_convert_string_to_utf8((unsigned char*) &text, (unsigned short *) &text_len,
 771                         display_text_tlv->text.dcs.a_format,
 772                         (unsigned char*) &display_text_tlv->text.string,
 773                         (unsigned short) display_text_tlv->text.string_length);
 774         dbg("sat display text(%s)",text);
 775
 776         //duration
 777         if(display_text_tlv->duration.time_interval){
 778                 tmp_duration = _get_time_in_ms(&display_text_tlv->duration);
 779         }
 780
 781         /* duration is required only when clear message after a delay
 782          * 27.22.4.1.7.4.2 DISPLAY TEXT ( Variable Timeout )
 783          */
 784         if(tmp_duration > 0) {
 785                 duration = tmp_duration;
 786         }
 787
 788         if(immediately_rsp && user_rsp_required)
 789                 duration = 0;
 790
 791         dbg("user rsp required(%d), immediately rsp(%d) duration (%d), priority(%d)",
 792                 user_rsp_required, immediately_rsp, duration, high_priority);
 793
 794 /*       ETSI TS 102 223 6.4.1 DISPLAY TEXT
 795          If help information is requested by the user, this command may be used to display help information on the screen. The
 796          help information should be sent as high priority text and with the option that it should be cleared after a short delay.*/
 797
 798 /*      if (ctx->help_requested == TRUE) {
 799                 ad->bIsPriorityHigh = TRUE;
 800                 ad->duration = 7000;
 801                 ctx->help_requested = FALSE;
 802         }*/
 803
 804         //enqueue data and generate cmd_id
 805         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
 806         q_data.cmd_type = SAT_PROATV_CMD_DISPLAY_TEXT;
 807         q_data.cp_name = g_strdup(cp_name);
 808         memcpy((void*)&(q_data.cmd_data.displayTextInd), display_text_tlv, sizeof(struct tel_sat_display_text_tlv));
 809         if(FALSE == sat_manager_enqueue_cmd(ctx, &q_data)){
 810                 g_free(q_data.cp_name);
 811         }
 812         command_id = q_data.cmd_id;
 813
 814 #if defined(TIZEN_SUPPORT_SAT_ICON)
 815         /* Icon data extraction */
 816         g_variant_builder_init(&v_builder_icon, G_VARIANT_TYPE ("a(biiiiiis)"));
 817         if(display_text_tlv->icon_id.is_exist) {
 818                 g_variant_builder_add(&v_builder_icon, "(biiiiiis)", display_text_tlv->icon_id.is_exist, display_text_tlv->icon_id.icon_qualifer, (gint32) display_text_tlv->icon_id.icon_identifier, (gint32) display_text_tlv->icon_id.icon_info.width,
 819                         (gint32) display_text_tlv->icon_id.icon_info.height, display_text_tlv->icon_id.icon_info.ics, display_text_tlv->icon_id.icon_info.icon_data_len, display_text_tlv->icon_id.icon_info.icon_file);
 820         }
 821         icon_id = g_variant_builder_end(&v_builder_icon);
 822
 823         display_text = g_variant_new("(isiibbbv)", command_id, text, text_len, duration,
 824                 high_priority, user_rsp_required, immediately_rsp, icon_id);
 825 #else
 826         display_text = g_variant_new("(isiibbb)", command_id, text, text_len, duration,
 827                 high_priority, user_rsp_required, immediately_rsp);
 828 #endif
 829
 830         return display_text;
 831 }
 832
 833 GVariant* sat_manager_select_item_noti(struct custom_data *ctx, const char *cp_name, struct tel_sat_select_item_tlv* select_item_tlv)
 834 {
 835         TcorePlugin *plg = NULL;
 836         GVariant *select_item = NULL;
 837         struct sat_manager_queue_data q_data;
 838
 839         gushort text_len = 0;
 840         gint command_id = 0, default_item_id = 0, menu_cnt = 0;
 841         gboolean help_info = FALSE;
 842         gchar text[SAT_TEXT_STRING_LEN_MAX+1];
 843         GVariantBuilder v_builder;
 844         GVariant *menu_items = NULL;
 845 #if defined(TIZEN_SUPPORT_SAT_ICON)
 846         int local_index = 0;
 847         GVariant *icon_id = NULL;
 848         GVariant *icon_list = NULL;
 849         GVariant *icon_list_info = NULL;
 850         GVariantBuilder v_builder_icon;
 851         GVariantBuilder v_builder_icon_list;
 852 #else
 853         int local_index = 0;
 854 #endif
 855         dbg("interpreting select item notification");
 856         memset(&text, 0 , SAT_TEXT_STRING_LEN_MAX+1);
 857
 858         plg = tcore_server_find_plugin(ctx->server, cp_name);
 859         if (!plg){
 860                 dbg("there is no valid plugin at this point");
 861                 return NULL;
 862         }
 863
 864         if(!select_item_tlv->menu_item_cnt || !select_item_tlv->menu_item[0].text_len){
 865                 struct treq_sat_terminal_rsp_data tr;
 866
 867                 dbg("select item - mandatory field does not exist");
 868
 869                 memset(&tr, 0, sizeof(struct treq_sat_terminal_rsp_data));
 870                 tr.cmd_number = select_item_tlv->command_detail.cmd_num;
 871                 tr.cmd_type = select_item_tlv->command_detail.cmd_type;
 872
 873                 memcpy((void*) &tr.terminal_rsp_data.select_item.command_detail,
 874                         &select_item_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
 875
 876                 tr.terminal_rsp_data.select_item.device_id.src = select_item_tlv->device_id.dest;
 877                 tr.terminal_rsp_data.select_item.device_id.dest = select_item_tlv->device_id.src;
 878                 tr.terminal_rsp_data.select_item.result_type = RESULT_BEYOND_ME_CAPABILITIES;
 879
 880                 sat_manager_send_terminal_response(ctx->comm, plg, &tr);
 881
 882                 return NULL;
 883         }
 884
 885         // help info
 886         help_info = select_item_tlv->command_detail.cmd_qualifier.select_item.help_info;
 887
 888         if(!select_item_tlv->alpha_id.is_exist){
 889                 dbg("set the item dcs value to ALPHABET_FORMAT_8BIT_DATA");
 890                 select_item_tlv->alpha_id.dcs.a_format = ALPHABET_FORMAT_8BIT_DATA;
 891         }
 892
 893         // select item text
 894         if(select_item_tlv->alpha_id.is_exist && select_item_tlv->alpha_id.alpha_data_len > 0)
 895                 tcore_util_convert_string_to_utf8((unsigned char*)&text,(unsigned short *)&text_len,
 896                                 select_item_tlv->alpha_id.dcs.a_format,
 897                                 (unsigned char*)&select_item_tlv->alpha_id.alpha_data,
 898                                 (unsigned short)select_item_tlv->alpha_id.alpha_data_len);
 899         dbg("select item text(%s)",text);
 900
 901         //default item id
 902         default_item_id = select_item_tlv->item_identifier.item_identifier;
 903         dbg( "default item id(%d)", default_item_id);
 904
 905         //item count
 906         menu_cnt = select_item_tlv->menu_item_cnt;
 907         dbg( "menu item count(%d)", menu_cnt);
 908
 909         //items
 910         g_variant_builder_init(&v_builder, G_VARIANT_TYPE ("a(iis)"));
 911         for(local_index= 0; local_index< menu_cnt; local_index++){
 912                 gushort item_len;
 913                 gchar item_str[SAT_ITEM_TEXT_LEN_MAX + 1];
 914
 915                 memset(&item_str, 0 , SAT_ITEM_TEXT_LEN_MAX + 1);
 916
 917                 tcore_util_convert_string_to_utf8((unsigned char*) &item_str, (unsigned short *) &item_len,
 918                                 select_item_tlv->menu_item[local_index].dcs.a_format,
 919                                 (unsigned char*) &select_item_tlv->menu_item[local_index].text,
 920                                 (unsigned short) select_item_tlv->menu_item[local_index].text_len);
 921
 922                 dbg( "index(%d) item_id(%d) item_len(%d) item_string(%s)", local_index, select_item_tlv->menu_item[local_index].item_id, item_len, item_str);
 923                 g_variant_builder_add(&v_builder, "(iis)", (gint32)(select_item_tlv->menu_item[local_index].item_id), item_len, item_str);
 924         }
 925         menu_items = g_variant_builder_end(&v_builder);
 926
 927         // generate command id
 928         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
 929         q_data.cmd_type = SAT_PROATV_CMD_SELECT_ITEM;
 930         q_data.cp_name = g_strdup(cp_name);
 931         memcpy((void*)&(q_data.cmd_data.selectItemInd), select_item_tlv, sizeof(struct tel_sat_select_item_tlv));
 932         if(FALSE == sat_manager_enqueue_cmd(ctx, &q_data)){
 933                 g_free(q_data.cp_name);
 934         }
 935         command_id = q_data.cmd_id;
 936
 937 #if defined(TIZEN_SUPPORT_SAT_ICON)
 938         /* Icon data extraction */
 939         g_variant_builder_init(&v_builder_icon, G_VARIANT_TYPE ("a(biiiiiis)"));
 940         if(select_item_tlv->icon_id.is_exist) {
 941                 g_variant_builder_add(&v_builder_icon, "(biiiiiis)", select_item_tlv->icon_id.is_exist, select_item_tlv->icon_id.icon_qualifer, (gint32) select_item_tlv->icon_id.icon_identifier, (gint32) select_item_tlv->icon_id.icon_info.width,
 942                         (gint32) select_item_tlv->icon_id.icon_info.height, select_item_tlv->icon_id.icon_info.ics, select_item_tlv->icon_id.icon_info.icon_data_len, select_item_tlv->icon_id.icon_info.icon_file);
 943         }
 944         icon_id = g_variant_builder_end(&v_builder_icon);
 945
 946         /* Icon list data extraction */
 947         g_variant_builder_init(&v_builder_icon, G_VARIANT_TYPE ("a(biiv)"));
 948         if(select_item_tlv->icon_list.is_exist) {
 949                 g_variant_builder_init(&v_builder_icon_list, G_VARIANT_TYPE ("a(iiiiis)"));
 950                 for(local_index= 0; local_index< (int)select_item_tlv->icon_list.icon_cnt; local_index++){
 951                         g_variant_builder_add(&v_builder_icon_list, "(iiiiis)", (gint32) select_item_tlv->icon_list.icon_id_list[local_index], (gint32) select_item_tlv->icon_list.icon_info[local_index].width,
 952                                 (gint32) select_item_tlv->icon_list.icon_info[local_index].height, select_item_tlv->icon_list.icon_info[local_index].ics, select_item_tlv->icon_list.icon_info[local_index].icon_data_len, select_item_tlv->icon_list.icon_info[local_index].icon_file);
 953                 }
 954                 icon_list_info = g_variant_builder_end(&v_builder_icon_list);
 955
 956                 g_variant_builder_add(&v_builder_icon, "(biiv)", select_item_tlv->icon_list.is_exist, select_item_tlv->icon_list.icon_qualifer, (gint32) select_item_tlv->icon_list.icon_cnt, icon_list_info);
 957
 958         }
 959         icon_list = g_variant_builder_end(&v_builder_icon);
 960
 961         select_item = g_variant_new("(ibsiiivvv)", command_id, help_info, text, text_len,
 962                         default_item_id, menu_cnt, menu_items, icon_id, icon_list);
 963 #else
 964         select_item = g_variant_new("(ibsiiiv)", command_id, help_info, text, text_len,
 965                         default_item_id, menu_cnt, menu_items);
 966 #endif
 967         return select_item;
 968 }
 969
 970 GVariant* sat_manager_get_inkey_noti(struct custom_data *ctx, const char *cp_name, struct tel_sat_get_inkey_tlv* get_inkey_tlv, int decode_error)
 971 {
 972         TcorePlugin *plg = NULL;
 973         GVariant *get_inkey = NULL;
 974         struct sat_manager_queue_data q_data;
 975
 976         gint command_id = 0, key_type = 0, input_character_mode = 0;
 977         gushort text_len = 0;
 978         gint duration = 0, tmp_duration = 0;
 979         gboolean b_numeric = FALSE, b_help_info = FALSE;
 980         gchar text[SAT_TEXT_STRING_LEN_MAX+1];
 981 #if defined(TIZEN_SUPPORT_SAT_ICON)
 982         GVariant *icon_id = NULL;
 983         GVariantBuilder v_builder_icon;
 984 #endif
 985         dbg("interpreting get inkey notification");
 986         memset(&text, 0 , SAT_TEXT_STRING_LEN_MAX+1);
 987
 988         plg = tcore_server_find_plugin(ctx->server, cp_name);
 989         if (!plg){
 990                 dbg("there is no valid plugin at this point");
 991                 return NULL;
 992         }
 993
 994         if(!get_inkey_tlv->text.string_length ||
 995                 (get_inkey_tlv->text.string_length > 0 && decode_error != TCORE_SAT_SUCCESS)){
 996                 struct treq_sat_terminal_rsp_data tr;
 997
 998                 dbg("get inkey - invalid parameter of TLVs is found!!");
 999
1000                 memset(&tr, 0, sizeof(struct treq_sat_terminal_rsp_data));
1001                 tr.cmd_number = get_inkey_tlv->command_detail.cmd_num;
1002                 tr.cmd_type = get_inkey_tlv->command_detail.cmd_type;
1003
1004                 memcpy((void*) &tr.terminal_rsp_data.get_inkey.command_detail,
1005                         &get_inkey_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
1006
1007                 tr.terminal_rsp_data.get_inkey.device_id.src = DEVICE_ID_ME;
1008                 tr.terminal_rsp_data.get_inkey.device_id.dest = DEVICE_ID_SIM;
1009                 tr.terminal_rsp_data.get_inkey.result_type = RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME;
1010
1011                 sat_manager_send_terminal_response(ctx->comm, plg, &tr);
1012
1013                 return NULL;
1014         }
1015
1016         //key type
1017         key_type = get_inkey_tlv->command_detail.cmd_qualifier.get_inkey.inkey_type;
1018
1019         //time duration
1020         duration = SAT_TIME_OUT;
1021         tmp_duration = _get_time_in_ms(&get_inkey_tlv->duration);
1022         if (tmp_duration > 0)
1023                 duration = tmp_duration;
1024
1025         //input mode
1026         input_character_mode = get_inkey_tlv->command_detail.cmd_qualifier.get_inkey.alphabet_type;
1027
1028         //numeric
1029         b_numeric = !get_inkey_tlv->command_detail.cmd_qualifier.get_inkey.alphabet_set;
1030
1031         //help info
1032         b_help_info = get_inkey_tlv->command_detail.cmd_qualifier.get_inkey.help_info;
1033
1034         //text & text len
1035         tcore_util_convert_string_to_utf8((unsigned char*)&text,(unsigned short *)&text_len,
1036                                                                 get_inkey_tlv->text.dcs.a_format ,
1037                                                                 (unsigned char*)&get_inkey_tlv->text.string,
1038                                                                 (unsigned short)get_inkey_tlv->text.string_length);
1039
1040         dbg("get inkey text(%s)",text);
1041
1042         if (get_inkey_tlv->command_detail.cmd_qualifier.get_inkey.immediate_rsp_required) {
1043                 dbg("get_inkey immediate_rsp_require is TRUE");
1044                 //Send TR if UI display success
1045         }
1046
1047         //enqueue data and generate cmd_id
1048         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
1049         q_data.cmd_type = SAT_PROATV_CMD_GET_INKEY;
1050         q_data.cp_name = g_strdup(cp_name);
1051         memcpy((void*)&(q_data.cmd_data.getInkeyInd), get_inkey_tlv, sizeof(struct tel_sat_get_inkey_tlv));
1052         if(FALSE == sat_manager_enqueue_cmd(ctx, &q_data)){
1053                 g_free(q_data.cp_name);
1054         }
1055         command_id = q_data.cmd_id;
1056
1057 #if defined(TIZEN_SUPPORT_SAT_ICON)
1058         /* Icon data extraction */
1059         g_variant_builder_init(&v_builder_icon, G_VARIANT_TYPE ("a(biiiiiis)"));
1060         if(get_inkey_tlv->icon_id.is_exist) {
1061                 g_variant_builder_add(&v_builder_icon, "(biiiiiis)", get_inkey_tlv->icon_id.is_exist, get_inkey_tlv->icon_id.icon_qualifer, (gint32) get_inkey_tlv->icon_id.icon_identifier, (gint32) get_inkey_tlv->icon_id.icon_info.width,
1062                                 (gint32) get_inkey_tlv->icon_id.icon_info.height, get_inkey_tlv->icon_id.icon_info.ics, get_inkey_tlv->icon_id.icon_info.icon_data_len, get_inkey_tlv->icon_id.icon_info.icon_file);
1063         }
1064         icon_id = g_variant_builder_end(&v_builder_icon);
1065
1066         get_inkey = g_variant_new("(iiibbsiiv)", command_id, key_type, input_character_mode, b_numeric,
1067                         b_help_info, text, text_len, duration, icon_id);
1068 #else
1069         get_inkey = g_variant_new("(iiibbsii)", command_id, key_type, input_character_mode, b_numeric,
1070                         b_help_info, text, text_len, duration);
1071 #endif
1072         return get_inkey;
1073 }
1074
1075 GVariant* sat_manager_get_input_noti(struct custom_data *ctx, const char *cp_name, struct tel_sat_get_input_tlv* get_input_tlv, int decode_error)
1076 {
1077         TcorePlugin *plg = NULL;
1078         GVariant *get_input = NULL;
1079         struct sat_manager_queue_data q_data;
1080
1081         gint command_id = 0, input_character_mode = 0;
1082         gushort text_len = 0, def_text_len = 0;
1083         gint rsp_len_min = 0, rsp_len_max = 0;
1084         gboolean b_numeric = FALSE, b_help_info = FALSE, b_echo_input = FALSE;
1085         gchar text[SAT_TEXT_STRING_LEN_MAX+1];
1086         gchar def_text[SAT_TEXT_STRING_LEN_MAX+1];
1087 #if defined(TIZEN_SUPPORT_SAT_ICON)
1088         GVariant *icon_id = NULL;
1089         GVariantBuilder v_builder_icon;
1090 #endif
1091         dbg("interpreting get input notification");
1092         memset(&text, 0 , SAT_TEXT_STRING_LEN_MAX+1);
1093         memset(&def_text, 0 , SAT_TEXT_STRING_LEN_MAX+1);
1094
1095         plg = tcore_server_find_plugin(ctx->server, cp_name);
1096         if (!plg){
1097                 dbg("there is no valid plugin at this point");
1098                 return NULL;
1099         }
1100
1101 #if GCF //disable the text length prb for GCF
1102         if(
1103                 (get_input_tlv->text.string_length > 0 && decode_error != TCORE_SAT_SUCCESS) ||
1104                 (!get_input_tlv->rsp_len.max) || (get_input_tlv->rsp_len.min > get_input_tlv->rsp_len.max)){
1105 #else
1106         if(!get_input_tlv->text.string_length ||
1107                 (get_input_tlv->text.string_length > 0 && decode_error != TCORE_SAT_SUCCESS) ||
1108                 (!get_input_tlv->rsp_len.max) || (get_input_tlv->rsp_len.min > get_input_tlv->rsp_len.max)){
1109 #endif
1110                 struct treq_sat_terminal_rsp_data tr;
1111
1112                 dbg("get input - invalid parameter of TLVs is found!!");
1113
1114                 memset(&tr, 0, sizeof(struct treq_sat_terminal_rsp_data));
1115                 tr.cmd_number = get_input_tlv->command_detail.cmd_num;
1116                 tr.cmd_type = get_input_tlv->command_detail.cmd_type;
1117
1118                 memcpy((void*) &tr.terminal_rsp_data.get_input.command_detail,
1119                         &get_input_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
1120
1121                 tr.terminal_rsp_data.get_input.device_id.src = DEVICE_ID_ME;
1122                 tr.terminal_rsp_data.get_input.device_id.dest = DEVICE_ID_SIM;
1123                 tr.terminal_rsp_data.get_input.result_type = RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME;
1124
1125                 sat_manager_send_terminal_response(ctx->comm, plg, &tr);
1126
1127                 return NULL;
1128         }
1129
1130         dbg( "[SAT]  is SMS7 packing required [%d]",get_input_tlv->command_detail.cmd_qualifier.get_input.user_input_unpacked_format);
1131
1132         //input mode
1133         input_character_mode =  get_input_tlv->command_detail.cmd_qualifier.get_input.alphabet_type;
1134
1135         //numeric
1136         b_numeric = !get_input_tlv->command_detail.cmd_qualifier.get_input.alphabet_set;
1137
1138         //help info
1139         b_help_info = get_input_tlv->command_detail.cmd_qualifier.get_input.help_info;
1140
1141         //echo input
1142         b_echo_input = get_input_tlv->command_detail.cmd_qualifier.get_input.me_echo_user_input;
1143         dbg("numeric (%d), help info(%d), echo input(%d)", b_numeric, b_help_info, b_echo_input);
1144
1145         //text & text len
1146         if(get_input_tlv->text.string_length){
1147                 tcore_util_convert_string_to_utf8((unsigned char*)&text,(unsigned short *)&text_len,
1148                                 get_input_tlv->text.dcs.a_format ,
1149                                 (unsigned char*)&get_input_tlv->text.string,
1150                                 (unsigned short)get_input_tlv->text.string_length);
1151                 dbg("get input text(%s)",text);
1152         }
1153
1154         //response length min & max
1155         rsp_len_min = get_input_tlv->rsp_len.min;
1156         rsp_len_max = get_input_tlv->rsp_len.max;
1157
1158         /* 27.22.4.3.4 Expected Seq.4.2 */
1159         if(input_character_mode == INPUT_ALPHABET_TYPE_UCS2 && rsp_len_max > SAT_USC2_INPUT_LEN_MAX)
1160                 rsp_len_max = SAT_USC2_INPUT_LEN_MAX;
1161
1162         //default text & default text len
1163         if(get_input_tlv->default_text.string_length){
1164                 int temp_len = get_input_tlv->default_text.string_length;
1165                 if(temp_len > rsp_len_max) {
1166                         dbg("get input def_text_len(%d) is larger than rsp_len_max(%d)", temp_len, rsp_len_max);
1167                         get_input_tlv->default_text.string_length = rsp_len_max;
1168                 }
1169                 tcore_util_convert_string_to_utf8((unsigned char*)&def_text,(unsigned short *)&def_text_len,
1170                                 get_input_tlv->default_text.dcs.a_format ,
1171                                 (unsigned char*)&get_input_tlv->default_text.string,
1172                                 (unsigned short)get_input_tlv->default_text.string_length);
1173                 dbg("get input default text(%s)",def_text);
1174         }
1175
1176         //enqueue data and generate cmd_id
1177         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
1178         q_data.cmd_type = SAT_PROATV_CMD_GET_INPUT;
1179         q_data.cp_name = g_strdup(cp_name);
1180         memcpy((void*)&(q_data.cmd_data.getInputInd), get_input_tlv, sizeof(struct tel_sat_get_input_tlv));
1181         if(FALSE == sat_manager_enqueue_cmd(ctx, &q_data)){
1182                 g_free(q_data.cp_name);
1183         }
1184         command_id = q_data.cmd_id;
1185
1186 #if defined(TIZEN_SUPPORT_SAT_ICON)
1187         /* Icon data extraction */
1188         g_variant_builder_init(&v_builder_icon, G_VARIANT_TYPE ("a(biiiiiis)"));
1189         if(get_input_tlv->icon_id.is_exist) {
1190                 g_variant_builder_add(&v_builder_icon, "(biiiiiis)", get_input_tlv->icon_id.is_exist, get_input_tlv->icon_id.icon_qualifer, (gint32) get_input_tlv->icon_id.icon_identifier, (gint32) get_input_tlv->icon_id.icon_info.width,
1191                                         (gint32) get_input_tlv->icon_id.icon_info.height, get_input_tlv->icon_id.icon_info.ics, get_input_tlv->icon_id.icon_info.icon_data_len, get_input_tlv->icon_id.icon_info.icon_file);
1192         }
1193         icon_id = g_variant_builder_end(&v_builder_icon);
1194
1195         get_input = g_variant_new("(iibbbsiiisiv)", command_id, input_character_mode, b_numeric, b_help_info,
1196                         b_echo_input, text, text_len, rsp_len_max, rsp_len_min, def_text, def_text_len, icon_id);
1197 #else
1198         get_input = g_variant_new("(iibbbsiiisi)", command_id, input_character_mode, b_numeric, b_help_info,
1199                         b_echo_input, text, text_len, rsp_len_max, rsp_len_min, def_text, def_text_len);
1200 #endif
1201         return get_input;
1202 }
1203
1204 GVariant* sat_manager_play_tone_noti(struct custom_data *ctx, const char *cp_name, struct tel_sat_play_tone_tlv* play_tone_tlv)
1205 {
1206         TcorePlugin *plg = NULL;
1207         GVariant *play_tone = NULL;
1208         struct sat_manager_queue_data q_data;
1209
1210         gint command_id = 0, tone_type = 0, duration = 0, tmp_duration = 0;
1211         gushort text_len = 0;
1212         gchar text[SAT_TEXT_STRING_LEN_MAX+1];
1213 #if defined(TIZEN_SUPPORT_SAT_ICON)
1214         GVariant *icon_id = NULL;
1215         GVariantBuilder v_builder_icon;
1216 #endif
1217         dbg("interpreting play tone notification");
1218         memset(&text, 0 , SAT_TEXT_STRING_LEN_MAX+1);
1219
1220         plg = tcore_server_find_plugin(ctx->server, cp_name);
1221         if (!plg){
1222                 dbg("there is no valid plugin at this point");
1223                 return NULL;
1224         }
1225
1226         //text and text len
1227         if( play_tone_tlv->alpha_id.is_exist && play_tone_tlv->alpha_id.alpha_data_len){
1228                 tcore_util_convert_string_to_utf8((unsigned char*)&text,(unsigned short *)&text_len,
1229                                 play_tone_tlv->alpha_id.dcs.a_format,
1230                                 (unsigned char*)&play_tone_tlv->alpha_id.alpha_data,
1231                                 (unsigned short)play_tone_tlv->alpha_id.alpha_data_len);
1232                 dbg("play tone ui display text (%s)",text);
1233         }
1234
1235         //tone type
1236         tone_type = play_tone_tlv->tone.tone_type;
1237
1238         //time duration
1239         duration = SAT_TIME_OUT;
1240         tmp_duration = _get_time_in_ms(&play_tone_tlv->duration);
1241         if (tmp_duration > 0)
1242                 duration = tmp_duration;
1243
1244         //enqueue data and generate cmd_id
1245         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
1246         q_data.cmd_type = SAT_PROATV_CMD_PLAY_TONE;
1247         q_data.cp_name = g_strdup(cp_name);
1248         memcpy((void*)&(q_data.cmd_data.play_tone), play_tone_tlv, sizeof(struct tel_sat_play_tone_tlv));
1249         if(FALSE == sat_manager_enqueue_cmd(ctx, &q_data)){
1250                 g_free(q_data.cp_name);
1251         }
1252         command_id = q_data.cmd_id;
1253
1254 #if defined(TIZEN_SUPPORT_SAT_ICON)
1255         /* Icon data extraction */
1256         g_variant_builder_init(&v_builder_icon, G_VARIANT_TYPE ("a(biiiiiis)"));
1257         if(play_tone_tlv->icon_id.is_exist) {
1258                 g_variant_builder_add(&v_builder_icon, "(biiiiiis)", play_tone_tlv->icon_id.is_exist, play_tone_tlv->icon_id.icon_qualifer, (gint32) play_tone_tlv->icon_id.icon_identifier, (gint32) play_tone_tlv->icon_id.icon_info.width,
1259                                         (gint32) play_tone_tlv->icon_id.icon_info.height, play_tone_tlv->icon_id.icon_info.ics, play_tone_tlv->icon_id.icon_info.icon_data_len, play_tone_tlv->icon_id.icon_info.icon_file);
1260         }
1261         icon_id = g_variant_builder_end(&v_builder_icon);
1262
1263         play_tone = g_variant_new("(isivii)", command_id, text, text_len, icon_id, tone_type, duration);
1264 #else
1265         play_tone = g_variant_new("(isiii)", command_id, text, text_len, tone_type, duration);
1266 #endif
1267         return play_tone;
1268 }
1269
1270 GVariant* sat_manager_send_sms_noti(struct custom_data *ctx, const char *cp_name, struct tel_sat_send_sms_tlv* send_sms_tlv)
1271 {
1272         TcorePlugin *plg = NULL;
1273         GVariant *send_sms = NULL;
1274         struct sat_manager_queue_data q_data;
1275
1276         int local_index = 0;
1277         gint command_id = 0, ton = 0, npi = 0, tpdu_type = 0;
1278         gboolean b_packing_required = FALSE;
1279         gushort text_len = 0, number_len = 0, tpdu_data_len= 0;
1280         gchar text[SAT_TEXT_STRING_LEN_MAX], dialling_number[SAT_DIALING_NUMBER_LEN_MAX];
1281         GVariantBuilder builder;
1282         GVariant *tpdu_data = NULL;
1283 #if defined(TIZEN_SUPPORT_SAT_ICON)
1284         GVariant *icon_id = NULL;
1285         GVariantBuilder v_builder_icon;
1286 #endif
1287         dbg("interpreting send sms notification");
1288         memset(&text, 0 , SAT_TEXT_STRING_LEN_MAX);
1289         memset(&dialling_number, 0 , SAT_DIALING_NUMBER_LEN_MAX);
1290
1291         plg = tcore_server_find_plugin(ctx->server, cp_name);
1292         if (!plg){
1293                 dbg("there is no valid plugin at this point");
1294                 return NULL;
1295         }
1296
1297         //text and text len
1298         if( send_sms_tlv->alpha_id.is_exist && send_sms_tlv->alpha_id.alpha_data_len){
1299                 tcore_util_convert_string_to_utf8((unsigned char*)&text,(unsigned short *)&text_len,
1300                                 send_sms_tlv->alpha_id.dcs.a_format,
1301                                 (unsigned char*)&send_sms_tlv->alpha_id.alpha_data,
1302                                 (unsigned short)send_sms_tlv->alpha_id.alpha_data_len);
1303                 dbg("send sms ui display text (%s)",text);
1304         }
1305         else{
1306                 memcpy(text,"",1);
1307                 text_len = 0;
1308         }
1309
1310         //packing required
1311         b_packing_required = send_sms_tlv->command_detail.cmd_qualifier.send_sms.packing_by_me_required;
1312
1313         //address : ton, npi, dialling number, number len
1314         ton = send_sms_tlv->address.ton;
1315         npi = send_sms_tlv->address.npi;
1316         number_len = send_sms_tlv->address.dialing_number_len;
1317         memcpy(dialling_number, send_sms_tlv->address.dialing_number, SAT_DIALING_NUMBER_LEN_MAX);
1318
1319         //tpdu data : type, data, data len
1320         tpdu_type = send_sms_tlv->sms_tpdu.tpdu_type;
1321         tpdu_data_len = send_sms_tlv->sms_tpdu.data_len;
1322         g_variant_builder_init(&builder, G_VARIANT_TYPE ("ay"));
1323         for (local_index= 0; local_index < tpdu_data_len; local_index++) {
1324                 g_variant_builder_add(&builder, "y", send_sms_tlv->sms_tpdu.data[local_index]);
1325         }
1326         tpdu_data = g_variant_builder_end(&builder);
1327
1328         //enqueue data and generate cmd_id
1329         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
1330         q_data.cmd_type = SAT_PROATV_CMD_SEND_SMS;
1331         q_data.cp_name = g_strdup(cp_name);
1332         memcpy((void*)&(q_data.cmd_data.sendSMSInd), send_sms_tlv, sizeof(struct tel_sat_send_sms_tlv));
1333         if(FALSE == sat_manager_enqueue_cmd(ctx, &q_data)){
1334                 g_free(q_data.cp_name);
1335         }
1336         command_id = q_data.cmd_id;
1337
1338 #if defined(TIZEN_SUPPORT_SAT_ICON)
1339         /* Icon data extraction */
1340         g_variant_builder_init(&v_builder_icon, G_VARIANT_TYPE ("a(biiiiiis)"));
1341         if(send_sms_tlv->icon_id.is_exist) {
1342                 g_variant_builder_add(&v_builder_icon, "(biiiiiis)", send_sms_tlv->icon_id.is_exist, send_sms_tlv->icon_id.icon_qualifer, (gint32) send_sms_tlv->icon_id.icon_identifier, (gint32) send_sms_tlv->icon_id.icon_info.width,
1343                                         (gint32) send_sms_tlv->icon_id.icon_info.height, send_sms_tlv->icon_id.icon_info.ics, send_sms_tlv->icon_id.icon_info.icon_data_len, send_sms_tlv->icon_id.icon_info.icon_file);
1344         }
1345         icon_id = g_variant_builder_end(&v_builder_icon);
1346
1347         send_sms = g_variant_new("(isivbiisiivi)", command_id, text, text_len, icon_id, b_packing_required,
1348                         ton, npi, dialling_number, number_len, tpdu_type, tpdu_data, tpdu_data_len);
1349 #else
1350         send_sms = g_variant_new("(isibiisiivi)", command_id, text, text_len, b_packing_required,
1351                         ton, npi, dialling_number, number_len, tpdu_type, tpdu_data, tpdu_data_len);
1352 #endif
1353         return send_sms;
1354 }
1355
1356 GVariant* sat_manager_send_ss_noti(struct custom_data *ctx, const char *cp_name, struct tel_sat_send_ss_tlv* send_ss_tlv)
1357 {
1358         TcorePlugin *plg = NULL;
1359         GVariant *send_ss = NULL;
1360         struct sat_manager_queue_data q_data;
1361
1362         gint command_id = 0, ton = 0, npi = 0;
1363         gushort text_len = 0;
1364         gint ss_str_len = 0;
1365         gchar text[SAT_TEXT_STRING_LEN_MAX], ss_string[SAT_SS_STRING_LEN_MAX];
1366 #if defined(TIZEN_SUPPORT_SAT_ICON)
1367         GVariant *icon_id = NULL;
1368         GVariantBuilder v_builder_icon;
1369 #endif
1370         dbg("interpreting send ss notification");
1371         memset(&text, 0 , SAT_TEXT_STRING_LEN_MAX);
1372         memset(&ss_string, 0 , SAT_SS_STRING_LEN_MAX);
1373
1374         plg = tcore_server_find_plugin(ctx->server, cp_name);
1375         if (!plg){
1376                 dbg("there is no valid plugin at this point");
1377                 return NULL;
1378         }
1379
1380         if(!send_ss_tlv->alpha_id.is_exist &&
1381                 (send_ss_tlv->icon_id.is_exist && send_ss_tlv->icon_id.icon_qualifer != ICON_QUALI_SELF_EXPLANATORY)){
1382                 struct treq_sat_terminal_rsp_data tr;
1383                 dbg("no alpha id and no self explanatory");
1384
1385                 memset(&tr, 0, sizeof(struct treq_sat_terminal_rsp_data));
1386                 tr.cmd_number = send_ss_tlv->command_detail.cmd_num;
1387                 tr.cmd_type = send_ss_tlv->command_detail.cmd_type;
1388
1389                 memcpy((void*)&tr.terminal_rsp_data.send_ss.command_detail, &send_ss_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
1390                 tr.terminal_rsp_data.send_ss.device_id.src = DEVICE_ID_ME;
1391                 tr.terminal_rsp_data.send_ss.device_id.dest = DEVICE_ID_SIM;
1392                 tr.terminal_rsp_data.send_ss.result_type = RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME;
1393
1394                 sat_manager_send_terminal_response(ctx->comm, plg, &tr);
1395                 return NULL;
1396         }
1397
1398         //text and text len
1399         if( send_ss_tlv->alpha_id.is_exist && send_ss_tlv->alpha_id.alpha_data_len){
1400                 tcore_util_convert_string_to_utf8((unsigned char*)&text,(unsigned short *)&text_len,
1401                                 send_ss_tlv->alpha_id.dcs.a_format,
1402                                 (unsigned char*)&send_ss_tlv->alpha_id.alpha_data,
1403                                 (unsigned short)send_ss_tlv->alpha_id.alpha_data_len);
1404                 dbg("send ss ui display text (%s)",text);
1405         }
1406
1407         //ss string: ton, npi, ss string len, ss string
1408         ton = send_ss_tlv->ss_string.ton;
1409         npi = send_ss_tlv->ss_string.npi;
1410         ss_str_len = send_ss_tlv->ss_string.string_len;
1411         memcpy(ss_string, send_ss_tlv->ss_string.ss_string, SAT_SS_STRING_LEN_MAX);
1412
1413         if(!ss_str_len || (ss_str_len > SAT_SS_STRING_LEN_MAX) ){
1414                 struct treq_sat_terminal_rsp_data tr;
1415                 dbg("no ss string");
1416
1417                 memset(&tr, 0, sizeof(struct treq_sat_terminal_rsp_data));
1418                 tr.cmd_number = send_ss_tlv->command_detail.cmd_num;
1419                 tr.cmd_type = send_ss_tlv->command_detail.cmd_type;
1420
1421                 memcpy((void*)&tr.terminal_rsp_data.send_ss.command_detail, &send_ss_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
1422                 tr.terminal_rsp_data.send_ss.device_id.src = DEVICE_ID_ME;
1423                 tr.terminal_rsp_data.send_ss.device_id.dest = DEVICE_ID_SIM;
1424                 tr.terminal_rsp_data.send_ss.result_type = RESULT_BEYOND_ME_CAPABILITIES;
1425
1426                 sat_manager_send_terminal_response(ctx->comm, plg, &tr);
1427                 return NULL;
1428         }
1429
1430         //enqueue data and generate cmd_id
1431         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
1432         q_data.cmd_type = SAT_PROATV_CMD_SEND_SS;
1433         q_data.cp_name = g_strdup(cp_name);
1434         memcpy((void*)&(q_data.cmd_data.send_ss), send_ss_tlv, sizeof(struct tel_sat_send_ss_tlv));
1435         if(FALSE == sat_manager_enqueue_cmd(ctx, &q_data)){
1436                 g_free(q_data.cp_name);
1437         }
1438         command_id = q_data.cmd_id;
1439
1440 #if defined(TIZEN_SUPPORT_SAT_ICON)
1441         /* Icon data extraction */
1442         g_variant_builder_init(&v_builder_icon, G_VARIANT_TYPE ("a(biiiiiis)"));
1443         if(send_ss_tlv->icon_id.is_exist) {
1444                 g_variant_builder_add(&v_builder_icon, "(biiiiiis)", send_ss_tlv->icon_id.is_exist, send_ss_tlv->icon_id.icon_qualifer, (gint32) send_ss_tlv->icon_id.icon_identifier, (gint32) send_ss_tlv->icon_id.icon_info.width,
1445                                         (gint32) send_ss_tlv->icon_id.icon_info.height, send_ss_tlv->icon_id.icon_info.ics, send_ss_tlv->icon_id.icon_info.icon_data_len, send_ss_tlv->icon_id.icon_info.icon_file);
1446         }
1447         icon_id = g_variant_builder_end(&v_builder_icon);
1448
1449         send_ss = g_variant_new("(isiviiis)", command_id, text, text_len, icon_id, ton, npi, ss_str_len, ss_string);
1450 #else
1451         send_ss = g_variant_new("(isiiiis)", command_id, text, text_len, ton, npi, ss_str_len, ss_string);
1452 #endif
1453         return send_ss;
1454 }
1455
1456 GVariant* sat_manager_send_ussd_noti(struct custom_data *ctx, const char *cp_name, struct tel_sat_send_ussd_tlv* send_ussd_tlv)
1457 {
1458         TcorePlugin *plg = NULL;
1459         GVariant *send_ussd = NULL;
1460         struct sat_manager_queue_data q_data;
1461
1462         gint command_id = 0;
1463         guchar dcs = 0;
1464         gushort text_len = 0, ussd_str_len = 0;
1465         gchar text[SAT_TEXT_STRING_LEN_MAX], ussd_string[SAT_USSD_STRING_LEN_MAX];
1466 #if defined(TIZEN_SUPPORT_SAT_ICON)
1467         GVariant *icon_id = NULL;
1468         GVariantBuilder v_builder_icon;
1469 #endif
1470         dbg("interpreting send ussd notification");
1471         memset(&text, 0 , SAT_TEXT_STRING_LEN_MAX);
1472         memset(&ussd_string, 0 , SAT_USSD_STRING_LEN_MAX);
1473
1474         plg = tcore_server_find_plugin(ctx->server, cp_name);
1475         if (!plg){
1476                 dbg("there is no valid plugin at this point");
1477                 return NULL;
1478         }
1479
1480         if(!send_ussd_tlv->alpha_id.is_exist &&
1481                 (send_ussd_tlv->icon_id.is_exist && send_ussd_tlv->icon_id.icon_qualifer != ICON_QUALI_SELF_EXPLANATORY)){
1482                 struct treq_sat_terminal_rsp_data tr;
1483                 dbg("no alpha id and no self explanatory");
1484
1485                 memset(&tr, 0, sizeof(struct treq_sat_terminal_rsp_data));
1486                 tr.cmd_number = send_ussd_tlv->command_detail.cmd_num;
1487                 tr.cmd_type = send_ussd_tlv->command_detail.cmd_type;
1488
1489                 memcpy((void*)&tr.terminal_rsp_data.send_ussd.command_detail, &send_ussd_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
1490                 tr.terminal_rsp_data.send_ussd.device_id.src = DEVICE_ID_ME;
1491                 tr.terminal_rsp_data.send_ussd.device_id.dest = DEVICE_ID_SIM;
1492                 tr.terminal_rsp_data.send_ussd.result_type = RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME;
1493
1494                 sat_manager_send_terminal_response(ctx->comm, plg, &tr);
1495                 return NULL;
1496         }
1497
1498         //text and text len
1499         if( send_ussd_tlv->alpha_id.is_exist && send_ussd_tlv->alpha_id.alpha_data_len){
1500                 tcore_util_convert_string_to_utf8((unsigned char*)&text,(unsigned short *)&text_len,
1501                                 send_ussd_tlv->alpha_id.dcs.a_format,
1502                                 (unsigned char*)&send_ussd_tlv->alpha_id.alpha_data,
1503                                 (unsigned short)send_ussd_tlv->alpha_id.alpha_data_len);
1504                 dbg("send ussd ui display text (%s)",text);
1505         }
1506
1507         //ussd string
1508         dcs = send_ussd_tlv->ussd_string.dsc.raw_dcs;
1509         tcore_util_convert_string_to_utf8((unsigned char*)&ussd_string,(unsigned short *)&ussd_str_len,
1510                                 send_ussd_tlv->ussd_string.dsc.a_format,
1511                                 (unsigned char*)&send_ussd_tlv->ussd_string.ussd_string,
1512                                 (unsigned short)send_ussd_tlv->ussd_string.string_len);
1513
1514
1515         if(!ussd_str_len || (ussd_str_len > SAT_USSD_STRING_LEN_MAX) ){
1516                 struct treq_sat_terminal_rsp_data tr;
1517                 dbg("no ss string");
1518
1519                 memset(&tr, 0, sizeof(struct treq_sat_terminal_rsp_data));
1520                 tr.cmd_number = send_ussd_tlv->command_detail.cmd_num;
1521                 tr.cmd_type = send_ussd_tlv->command_detail.cmd_type;
1522
1523                 memcpy((void*)&tr.terminal_rsp_data.send_ussd.command_detail, &send_ussd_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
1524                 tr.terminal_rsp_data.send_ussd.device_id.src = DEVICE_ID_ME;
1525                 tr.terminal_rsp_data.send_ussd.device_id.dest = DEVICE_ID_SIM;
1526                 tr.terminal_rsp_data.send_ussd.result_type = RESULT_BEYOND_ME_CAPABILITIES;
1527
1528                 sat_manager_send_terminal_response(ctx->comm, plg, &tr);
1529                 return NULL;
1530         }
1531
1532         //enqueue data and generate cmd_id
1533         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
1534         q_data.cmd_type = SAT_PROATV_CMD_SEND_USSD;
1535         q_data.cp_name = g_strdup(cp_name);
1536         memcpy((void*)&(q_data.cmd_data.send_ussd), send_ussd_tlv, sizeof(struct tel_sat_send_ussd_tlv));
1537         if(FALSE == sat_manager_enqueue_cmd(ctx, &q_data)){
1538                 g_free(q_data.cp_name);
1539         }
1540         command_id = q_data.cmd_id;
1541
1542 #if defined(TIZEN_SUPPORT_SAT_ICON)
1543         /* Icon data extraction */
1544         g_variant_builder_init(&v_builder_icon, G_VARIANT_TYPE ("a(biiiiiis)"));
1545         if(send_ussd_tlv->icon_id.is_exist) {
1546                 g_variant_builder_add(&v_builder_icon, "(biiiiiis)", send_ussd_tlv->icon_id.is_exist, send_ussd_tlv->icon_id.icon_qualifer, (gint32) send_ussd_tlv->icon_id.icon_identifier, (gint32) send_ussd_tlv->icon_id.icon_info.width,
1547                                         (gint32) send_ussd_tlv->icon_id.icon_info.height, send_ussd_tlv->icon_id.icon_info.ics, send_ussd_tlv->icon_id.icon_info.icon_data_len, send_ussd_tlv->icon_id.icon_info.icon_file);
1548         }
1549         icon_id = g_variant_builder_end(&v_builder_icon);
1550
1551         send_ussd = g_variant_new("(isivyis)", command_id, text, text_len, icon_id, dcs, ussd_str_len, ussd_string);
1552 #else
1553         send_ussd = g_variant_new("(isiyis)", command_id, text, text_len, dcs, ussd_str_len, ussd_string);
1554 #endif
1555         return send_ussd;
1556 }
1557
1558 GVariant* sat_manager_setup_call_noti(struct custom_data *ctx, const char *cp_name, struct tel_sat_setup_call_tlv* setup_call_tlv)
1559 {
1560         TcorePlugin *plg = NULL;
1561         GVariant *setup_call = NULL;
1562         struct sat_manager_queue_data q_data;
1563         struct treq_sat_terminal_rsp_data tr;
1564
1565         gushort text_len = 0, confirm_text_len = 0;
1566         gint command_id = 0, call_type = 0, duration = 0;
1567         gchar confirm_text[SAT_TEXT_STRING_LEN_MAX], text[SAT_TEXT_STRING_LEN_MAX], call_number[SAT_DIALING_NUMBER_LEN_MAX];
1568 #if defined(TIZEN_SUPPORT_SAT_ICON)
1569         GVariant *icon_id = NULL;
1570         GVariantBuilder v_builder_icon;
1571 #endif
1572         dbg("interpreting setup call notification");
1573         memset(&confirm_text, 0 , SAT_TEXT_STRING_LEN_MAX);
1574         memset(&text, 0 , SAT_TEXT_STRING_LEN_MAX);
1575         memset(&call_number, 0 , SAT_DIALING_NUMBER_LEN_MAX);
1576         memset(&tr, 0, sizeof(struct treq_sat_terminal_rsp_data));
1577
1578         plg = tcore_server_find_plugin(ctx->server, cp_name);
1579         if (!plg){
1580                 dbg("there is no valid plugin at this point");
1581                 return NULL;
1582         }
1583
1584         if(setup_call_tlv->duration.time_interval > 0)
1585         {
1586                 dbg("[SAT] redial is not supported.\n");
1587                 tr.terminal_rsp_data.setup_call.result_type = RESULT_BEYOND_ME_CAPABILITIES;
1588                 goto SEND_TR;
1589         }
1590
1591         //check for subaddress field
1592         if(setup_call_tlv->subaddress.subaddress_len > 0)
1593         {
1594                 dbg("[SAT] Sub address is not supported > 0)");
1595                 tr.terminal_rsp_data.setup_call.result_type = RESULT_BEYOND_ME_CAPABILITIES;
1596                 goto SEND_TR;
1597                 return NULL;
1598         }
1599
1600         if(setup_call_tlv->command_detail.cmd_qualifier.setup_call.setup_call == SETUP_CALL_IF_ANOTHER_CALL_NOT_BUSY ||
1601            setup_call_tlv->command_detail.cmd_qualifier.setup_call.setup_call == SETUP_CALL_IF_ANOTHER_CALL_NOT_BUSY_WITH_REDIAL)
1602         {
1603                 GSList *co_list = NULL;
1604                 CoreObject *co_call = NULL;
1605                 int total_call_cnt = 0;
1606
1607                 co_list = tcore_plugin_get_core_objects_bytype(plg, CORE_OBJECT_TYPE_CALL);
1608                 if ( !co_list ) {
1609                         dbg("[ error ] co_list : 0");
1610                         tr.terminal_rsp_data.setup_call.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
1611                         goto SEND_TR;
1612                 }
1613
1614                 co_call = (CoreObject *)co_list->data;
1615                 g_slist_free(co_list);
1616                 total_call_cnt = tcore_call_object_total_length(co_call);
1617                 if (total_call_cnt){
1618                         dbg("[SAT] Another call in progress hence rejecting. total_call_cnt: %d", total_call_cnt);
1619                         tr.terminal_rsp_data.setup_call.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
1620                         tr.terminal_rsp_data.setup_call.me_problem_type = ME_PROBLEM_ME_BUSY_ON_CALL;
1621                         goto SEND_TR;
1622                 }
1623         }
1624
1625         //call type
1626         call_type = setup_call_tlv->command_detail.cmd_qualifier.setup_call.setup_call;
1627
1628         //call display data
1629         if(setup_call_tlv->call_setup_alpha_id.alpha_data_len != 0){
1630                 tcore_util_convert_string_to_utf8((unsigned char*)&text,(unsigned short *)&text_len,
1631                                 setup_call_tlv->call_setup_alpha_id.dcs.a_format,
1632                                 (unsigned char*)&setup_call_tlv->call_setup_alpha_id.alpha_data,
1633                                 (unsigned short)setup_call_tlv->call_setup_alpha_id.alpha_data_len);
1634         }
1635         dbg("setup call display text (%s)",text);
1636
1637         if(setup_call_tlv->user_confirm_alpha_id.alpha_data_len != 0){
1638                 tcore_util_convert_string_to_utf8((unsigned char*)&confirm_text,(unsigned short *)&confirm_text_len,
1639                                 setup_call_tlv->user_confirm_alpha_id.dcs.a_format,
1640                                 (unsigned char*)&setup_call_tlv->user_confirm_alpha_id.alpha_data,
1641                                 (unsigned short)setup_call_tlv->user_confirm_alpha_id.alpha_data_len);
1642         }
1643
1644         //call number
1645         if(setup_call_tlv->address.ton == TON_INTERNATIONAL){
1646                 call_number[0] = '+';
1647                 memcpy(&call_number[1],setup_call_tlv->address.dialing_number, setup_call_tlv->address.dialing_number_len);
1648         }
1649         else{
1650                 memcpy(call_number,setup_call_tlv->address.dialing_number, setup_call_tlv->address.dialing_number_len);
1651         }
1652         dbg("setup call call number: origin(%s), final(%s)",setup_call_tlv->address.dialing_number, call_number);
1653
1654         //duration
1655         if(setup_call_tlv->duration.time_interval > 0)
1656                 duration = _get_time_in_ms(&setup_call_tlv->duration);
1657
1658         //enqueue data and generate cmd_id
1659         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
1660         q_data.cmd_type = SAT_PROATV_CMD_SETUP_CALL;
1661         q_data.cp_name = g_strdup(cp_name);
1662         memcpy((void*)&(q_data.cmd_data.setup_call), setup_call_tlv, sizeof(struct tel_sat_setup_call_tlv));
1663         if(FALSE == sat_manager_enqueue_cmd(ctx, &q_data)){
1664                 g_free(q_data.cp_name);
1665         }
1666         command_id = q_data.cmd_id;
1667
1668 #if defined(TIZEN_SUPPORT_SAT_ICON)
1669         /* Icon data extraction */
1670         g_variant_builder_init(&v_builder_icon, G_VARIANT_TYPE ("a(biiiiiis)"));
1671         if(setup_call_tlv->call_setup_icon_id.is_exist) {
1672                 g_variant_builder_add(&v_builder_icon, "(biiiiiis)", setup_call_tlv->call_setup_icon_id.is_exist, setup_call_tlv->call_setup_icon_id.icon_qualifer, (gint32) setup_call_tlv->call_setup_icon_id.icon_identifier, (gint32) setup_call_tlv->call_setup_icon_id.icon_info.width,
1673                                         (gint32) setup_call_tlv->call_setup_icon_id.icon_info.height, setup_call_tlv->call_setup_icon_id.icon_info.ics, setup_call_tlv->call_setup_icon_id.icon_info.icon_data_len, setup_call_tlv->call_setup_icon_id.icon_info.icon_file);
1674         }
1675         icon_id = g_variant_builder_end(&v_builder_icon);
1676
1677         setup_call = g_variant_new("(isisivisi)", command_id, confirm_text, confirm_text_len, text, text_len, icon_id, call_type, call_number, duration);
1678 #else
1679         setup_call = g_variant_new("(isisiisi)", command_id, confirm_text, confirm_text_len, text, text_len, call_type, call_number, duration);
1680 #endif
1681         return setup_call;
1682
1683 SEND_TR:
1684         tr.cmd_number = setup_call_tlv->command_detail.cmd_num;
1685         tr.cmd_type = setup_call_tlv->command_detail.cmd_type;
1686         memcpy((void*)&tr.terminal_rsp_data.setup_call.command_detail, &setup_call_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
1687         tr.terminal_rsp_data.setup_call.device_id.src = DEVICE_ID_ME;
1688         tr.terminal_rsp_data.setup_call.device_id.dest = setup_call_tlv->device_id.src;
1689         sat_manager_send_terminal_response(ctx->comm, plg, &tr);
1690         return NULL;
1691 }
1692
1693 GVariant* sat_manager_setup_event_list_noti(struct custom_data *ctx, const char *cp_name, struct tel_sat_setup_event_list_tlv *event_list_tlv)
1694 {
1695         TcorePlugin *plg = NULL;
1696         GVariant *event_list = NULL;
1697
1698         int local_index = 0;
1699         gboolean rv = FALSE;
1700         gint event_cnt = 0;
1701         GVariantBuilder builder;
1702         GVariant *evt_list = NULL;
1703         struct treq_sat_terminal_rsp_data *tr = NULL;
1704
1705         dbg("interpreting event list notification");
1706
1707         plg = tcore_server_find_plugin(ctx->server, cp_name);
1708         if (!plg){
1709                 dbg("there is no valid plugin at this point");
1710                 return NULL;
1711         }
1712
1713         //event cnt
1714         event_cnt = event_list_tlv->event_list.event_list_cnt;
1715         dbg("event cnt(%d)", event_cnt);
1716         // reset evnet list
1717         memset(g_evt_list, 0, SAT_EVENT_DOWNLOAD_MAX);
1718
1719         //get event
1720         g_variant_builder_init(&builder, G_VARIANT_TYPE ("ai"));
1721         for (local_index = 0; local_index < event_cnt; local_index++) {
1722                 g_variant_builder_add(&builder, "i", event_list_tlv->event_list.evt_list[local_index]);
1723                 if(event_list_tlv->event_list.evt_list[local_index] >= SAT_EVENT_DOWNLOAD_MAX)
1724                         continue;
1725                 g_evt_list[event_list_tlv->event_list.evt_list[local_index]] = TRUE;
1726         }
1727         evt_list = g_variant_builder_end(&builder);
1728
1729         event_list = g_variant_new("(iv)", event_cnt, evt_list);
1730
1731         //send TR - does not need from application's response
1732         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
1733         if (!tr)
1734                 return NULL;
1735         tr->cmd_number = event_list_tlv->command_detail.cmd_num;
1736         tr->cmd_type = event_list_tlv->command_detail.cmd_type;
1737         memcpy((void*)&tr->terminal_rsp_data.setup_event_list.command_detail, &event_list_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
1738         tr->terminal_rsp_data.setup_event_list.device_id.src = event_list_tlv->device_id.dest;
1739         tr->terminal_rsp_data.setup_event_list.device_id.dest = event_list_tlv->device_id.src;
1740         tr->terminal_rsp_data.setup_event_list.result_type = RESULT_SUCCESS;
1741         tr->terminal_rsp_data.setup_event_list.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
1742
1743         rv = sat_manager_check_availiable_event_list(event_list_tlv);
1744         dbg("rv of sat_manager_check_availiable_event_list()=[%d]", rv);
1745
1746         sat_manager_send_terminal_response(ctx->comm, plg, tr);
1747         g_free(tr);
1748
1749         return event_list;
1750 }
1751
1752 GVariant* sat_manager_setup_idle_mode_text_noti(struct custom_data *ctx, const char *cp_name, struct tel_sat_setup_idle_mode_text_tlv *idle_mode_tlv, int decode_error)
1753 {
1754         TcorePlugin *plg = NULL;
1755         GVariant *idle_mode = NULL;
1756         struct sat_manager_queue_data q_data;
1757
1758         gint command_id = 0;
1759         gushort text_len = 0;
1760         gchar text[SAT_TEXT_STRING_LEN_MAX+1];
1761 #if defined(TIZEN_SUPPORT_SAT_ICON)
1762         GVariant *icon_id = NULL;
1763         GVariantBuilder v_builder_icon;
1764 #endif
1765         dbg("interpreting setup idle mode text notification");
1766         memset(&text, 0 , SAT_TEXT_STRING_LEN_MAX+1);
1767
1768         plg = tcore_server_find_plugin(ctx->server, cp_name);
1769         if (!plg){
1770                 dbg("there is no valid plugin at this point");
1771                 return NULL;
1772         }
1773
1774
1775         if(!idle_mode_tlv->text.string_length && decode_error != TCORE_SAT_SUCCESS){
1776                 struct treq_sat_terminal_rsp_data tr;
1777
1778                 dbg("setup idle mode text - invalid parameter of TLVs is found!!");
1779
1780                 memset(&tr, 0, sizeof(struct treq_sat_terminal_rsp_data));
1781                 tr.cmd_number = idle_mode_tlv->command_detail.cmd_num;
1782                 tr.cmd_type = idle_mode_tlv->command_detail.cmd_type;
1783
1784                 memcpy((void*) &tr.terminal_rsp_data.setup_idle_mode_text.command_detail,
1785                         &idle_mode_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
1786
1787                 tr.terminal_rsp_data.setup_idle_mode_text.device_id.src = DEVICE_ID_ME;
1788                 tr.terminal_rsp_data.setup_idle_mode_text.device_id.dest = DEVICE_ID_SIM;
1789                 tr.terminal_rsp_data.setup_idle_mode_text.result_type = RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME;
1790
1791                 sat_manager_send_terminal_response(ctx->comm, plg, &tr);
1792
1793                 return NULL;
1794         }
1795
1796         tcore_util_convert_string_to_utf8((unsigned char*)&text,(unsigned short *)&text_len,
1797                         idle_mode_tlv->text.dcs.a_format,
1798                         (unsigned char*)&idle_mode_tlv->text.string,
1799                         (unsigned short)idle_mode_tlv->text.string_length);
1800
1801         dbg("setup idle mode text display text (%s)",text);
1802
1803         //enqueue data and generate cmd_id
1804         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
1805         q_data.cmd_type = SAT_PROATV_CMD_SETUP_IDLE_MODE_TEXT;
1806         q_data.cp_name = g_strdup(cp_name);
1807         memcpy((void*)&(q_data.cmd_data.idle_mode), idle_mode_tlv, sizeof(struct tel_sat_setup_idle_mode_text_tlv));
1808         if(FALSE == sat_manager_enqueue_cmd(ctx, &q_data)){
1809                 g_free(q_data.cp_name);
1810         }
1811         command_id = q_data.cmd_id;
1812
1813 #if defined(TIZEN_SUPPORT_SAT_ICON)
1814         /* Icon data extraction */
1815         g_variant_builder_init(&v_builder_icon, G_VARIANT_TYPE ("a(biiiiiis)"));
1816         if(idle_mode_tlv->icon_id.is_exist) {
1817                 g_variant_builder_add(&v_builder_icon, "(biiiiiis)", idle_mode_tlv->icon_id.is_exist, idle_mode_tlv->icon_id.icon_qualifer, (gint32) idle_mode_tlv->icon_id.icon_identifier, (gint32) idle_mode_tlv->icon_id.icon_info.width,
1818                                         (gint32) idle_mode_tlv->icon_id.icon_info.height, idle_mode_tlv->icon_id.icon_info.ics, idle_mode_tlv->icon_id.icon_info.icon_data_len, idle_mode_tlv->icon_id.icon_info.icon_file);
1819         }
1820         icon_id = g_variant_builder_end(&v_builder_icon);
1821
1822         idle_mode = g_variant_new("(isiv)", command_id, text, text_len, icon_id);
1823 #else
1824         idle_mode = g_variant_new("(isi)", command_id, text, text_len);
1825 #endif
1826         return idle_mode;
1827 }
1828
1829 GVariant* sat_manager_open_channel_noti(struct custom_data *ctx, const char *cp_name, struct tel_sat_open_channel_tlv *open_channel_tlv)
1830 {
1831         TcorePlugin *plg = NULL;
1832         CoreObject *co_call = NULL;
1833         CoreObject *co_network = NULL;
1834
1835         GSList* call_active_list = NULL;
1836         enum telephony_network_access_technology result = 0;
1837
1838         GVariant *open_channel = NULL;
1839         struct sat_manager_queue_data q_data;
1840
1841         gint command_id = 0, bearer_type = 0, protocol_type = 0, dest_addr_type = 0;
1842         gboolean immediate_link = FALSE, auto_reconnection = FALSE, bg_mode = FALSE;
1843         gushort text_len = 0;
1844         gint buffer_size = 0, port_number = 0;
1845         gchar text[SAT_ALPHA_ID_LEN_MAX], dest_address[SAT_OTHER_ADDR_LEN_MAX];
1846         GVariant *bearer_param = NULL;
1847         GVariant *bearer_detail = NULL;
1848 #if defined(TIZEN_SUPPORT_SAT_ICON)
1849         GVariant *icon_id = NULL;
1850         GVariantBuilder v_builder_icon;
1851 #endif
1852         dbg("interpreting open channel notification");
1853         memset(&text, 0 , SAT_ALPHA_ID_LEN_MAX);
1854         memset(&dest_address, 0 , SAT_OTHER_ADDR_LEN_MAX);
1855
1856         plg = tcore_server_find_plugin(ctx->server, cp_name);
1857         if (!plg){
1858                 dbg("there is no valid plugin at this point");
1859                 return NULL;
1860         }
1861
1862         co_call = tcore_plugin_ref_core_object(plg, CORE_OBJECT_TYPE_CALL);
1863         co_network = tcore_plugin_ref_core_object(plg, CORE_OBJECT_TYPE_NETWORK);
1864         if(!co_call || !co_network){
1865                 struct treq_sat_terminal_rsp_data tr;
1866                 dbg("call or network co_obj does not exist");
1867
1868                 memset(&tr, 0, sizeof(struct treq_sat_terminal_rsp_data));
1869                 tr.cmd_number = open_channel_tlv->command_detail.cmd_num;
1870                 tr.cmd_type = open_channel_tlv->command_detail.cmd_type;
1871
1872                 memcpy((void*)&tr.terminal_rsp_data.open_channel.command_detail, &open_channel_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
1873                 tr.terminal_rsp_data.open_channel.device_id.src = DEVICE_ID_ME;
1874                 tr.terminal_rsp_data.open_channel.device_id.dest = DEVICE_ID_SIM;
1875                 tr.terminal_rsp_data.open_channel.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
1876                 tr.terminal_rsp_data.open_channel.me_problem_type = ME_PROBLEM_NO_SERVICE;
1877
1878                 memcpy((void*)&tr.terminal_rsp_data.open_channel.bearer_desc, &open_channel_tlv->bearer_desc, sizeof(struct tel_sat_bearer_description));
1879                 sat_manager_send_terminal_response(ctx->comm, plg, &tr);
1880
1881                 return NULL;
1882         }
1883
1884         call_active_list = tcore_call_object_find_by_status(co_call, TCORE_CALL_STATUS_ACTIVE);
1885         tcore_network_get_access_technology(co_network,&result);
1886         if(result < NETWORK_ACT_UMTS && call_active_list){
1887                 struct treq_sat_terminal_rsp_data tr;
1888                 dbg("call is busy in not 3G state atc(%d)", result);
1889
1890                 memset(&tr, 0, sizeof(struct treq_sat_terminal_rsp_data));
1891                 tr.cmd_number = open_channel_tlv->command_detail.cmd_num;
1892                 tr.cmd_type = open_channel_tlv->command_detail.cmd_type;
1893
1894                 memcpy((void*)&tr.terminal_rsp_data.open_channel.command_detail, &open_channel_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
1895                 tr.terminal_rsp_data.open_channel.device_id.src = DEVICE_ID_ME;
1896                 tr.terminal_rsp_data.open_channel.device_id.dest = DEVICE_ID_SIM;
1897                 tr.terminal_rsp_data.open_channel.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
1898                 tr.terminal_rsp_data.open_channel.me_problem_type = ME_PROBLEM_ME_BUSY_ON_CALL;
1899
1900                 memcpy((void*)&tr.terminal_rsp_data.open_channel.bearer_desc, &open_channel_tlv->bearer_desc, sizeof(struct tel_sat_bearer_description));
1901                 sat_manager_send_terminal_response(ctx->comm, plg, &tr);
1902                 g_slist_free(call_active_list);
1903                 return NULL;
1904         }
1905
1906
1907         //immediate link
1908         immediate_link = open_channel_tlv->command_detail.cmd_qualifier.open_channel.immediate_link;
1909
1910         //auto reconnection
1911         auto_reconnection = open_channel_tlv->command_detail.cmd_qualifier.open_channel.automatic_reconnection;
1912
1913         //back ground mode
1914         bg_mode = open_channel_tlv->command_detail.cmd_qualifier.open_channel.background_mode;
1915
1916         //open channel text
1917         if(open_channel_tlv->alpha_id.is_exist && open_channel_tlv->alpha_id.alpha_data_len > 0)
1918                 tcore_util_convert_string_to_utf8((unsigned char*)&text,(unsigned short *)&text_len,
1919                                 open_channel_tlv->alpha_id.dcs.a_format,
1920                                 (unsigned char*)&open_channel_tlv->alpha_id.alpha_data,
1921                                 (unsigned short)open_channel_tlv->alpha_id.alpha_data_len);
1922         dbg("open channel text(%s)",text);
1923
1924         //buffer size
1925         buffer_size = open_channel_tlv->buffer_size.size[0];
1926         buffer_size = buffer_size << 8;
1927         buffer_size += open_channel_tlv->buffer_size.size[1];
1928         //memcpy(&buffer_size, open_channel_tlv->buffer_size.size, sizeof(unsigned char)*2);
1929         dbg("buffer size(%d)", buffer_size);
1930
1931         //interface transport level
1932         protocol_type = open_channel_tlv->interface_transport_level.protocol_type;
1933         port_number = open_channel_tlv->interface_transport_level.port_number;
1934
1935         //data destination address
1936         dest_addr_type = open_channel_tlv->data_destination_address.address_type;
1937         memcpy(dest_address,  open_channel_tlv->data_destination_address.address,
1938                         open_channel_tlv->data_destination_address.address_len);
1939         dbg("destination IP address (%s)", dest_address);
1940
1941         //bearer type
1942         bearer_type = open_channel_tlv->bearer_desc.bearer_type;
1943
1944         //bearer param & bearer detail
1945         switch(bearer_type){
1946                 case BEARER_CSD:{
1947                         //bearer param
1948                         gint data_rate = 0, service_type = 0, conn_element_type = 0;
1949
1950                         //bearer detail
1951                         gint ton = 0, npi = 0, time_duration1 = 0, time_duration2 = 0, other_addr_type = 0;
1952                         gushort login_len = 0, pwd_len = 0;
1953                         gchar dialling_number[SAT_DIALING_NUMBER_LEN_MAX], sub_addr[SAT_SUB_ADDR_LEN_MAX];
1954                         gchar other_address[SAT_OTHER_ADDR_LEN_MAX];
1955                         gchar login[SAT_TEXT_STRING_LEN_MAX], pwd[SAT_TEXT_STRING_LEN_MAX];
1956
1957                         memset(&dialling_number, 0 , SAT_DIALING_NUMBER_LEN_MAX);
1958                         memset(&sub_addr, 0 , SAT_SUB_ADDR_LEN_MAX);
1959                         memset(&other_address, 0 , SAT_OTHER_ADDR_LEN_MAX);
1960                         memset(&login, 0 , SAT_TEXT_STRING_LEN_MAX);
1961                         memset(&pwd, 0 , SAT_TEXT_STRING_LEN_MAX);
1962
1963                         //bearer parameter
1964                         data_rate = open_channel_tlv->bearer_desc.bearer_parameter.cs_bearer_param.data_rate;
1965                         service_type = open_channel_tlv->bearer_desc.bearer_parameter.cs_bearer_param.service_type;
1966                         conn_element_type = open_channel_tlv->bearer_desc.bearer_parameter.cs_bearer_param.connection_element_type;
1967
1968                         bearer_param = g_variant_new("(iii)", data_rate, service_type, conn_element_type);
1969
1970                         //bearer detail
1971                         ton = open_channel_tlv->bearer_detail.cs_bearer.address.ton;
1972                         npi = open_channel_tlv->bearer_detail.cs_bearer.address.npi;
1973                         memcpy(dialling_number, open_channel_tlv->bearer_detail.cs_bearer.address.dialing_number, open_channel_tlv->bearer_detail.cs_bearer.address.dialing_number_len);
1974
1975                         memcpy(sub_addr, open_channel_tlv->bearer_detail.cs_bearer.subaddress.subaddress, open_channel_tlv->bearer_detail.cs_bearer.subaddress.subaddress_len);
1976
1977                         time_duration1 = _get_time_in_ms(&open_channel_tlv->bearer_detail.cs_bearer.duration1);
1978                         time_duration2 = _get_time_in_ms(&open_channel_tlv->bearer_detail.cs_bearer.duration2);
1979
1980                         other_addr_type = open_channel_tlv->bearer_detail.cs_bearer.other_address.address_type;
1981                         memcpy(other_address, open_channel_tlv->bearer_detail.cs_bearer.other_address.address, open_channel_tlv->bearer_detail.cs_bearer.other_address.address_len);
1982
1983                         tcore_util_convert_string_to_utf8((unsigned char*) &login, (unsigned short *) &login_len,
1984                                         open_channel_tlv->bearer_detail.cs_bearer.text_user_login.dcs.a_format,
1985                                         (unsigned char*) &open_channel_tlv->bearer_detail.cs_bearer.text_user_login.string,
1986                                         (unsigned short) open_channel_tlv->bearer_detail.cs_bearer.text_user_login.string_length);
1987
1988                         tcore_util_convert_string_to_utf8((unsigned char*) &pwd, (unsigned short *) &pwd_len,
1989                                         open_channel_tlv->bearer_detail.cs_bearer.text_user_pwd.dcs.a_format,
1990                                         (unsigned char*) &open_channel_tlv->bearer_detail.cs_bearer.text_user_pwd.string,
1991                                         (unsigned short) open_channel_tlv->bearer_detail.cs_bearer.text_user_pwd.string_length);
1992
1993                         bearer_detail= g_variant_new("(iissiiisss)", ton, npi, dialling_number, sub_addr, time_duration1, time_duration2,
1994                                         other_addr_type, other_address, login, pwd);
1995                 } break;
1996                 case BEARER_GPRS:{
1997                         //bearer param
1998                         gint precedence_class = 0, delay_class = 0, reliability_class = 0;
1999                         gint peak_class = 0, mean_class = 0, pdp_type = 0;
2000
2001                         //bearer detail
2002                         gint other_addr_type = 0;
2003                         gushort login_len = 0, pwd_len = 0;
2004                         gchar network_access_name[SAT_NET_ACC_NAM_LEN_MAX];
2005                         gchar other_address[SAT_OTHER_ADDR_LEN_MAX];
2006                         gchar login[SAT_TEXT_STRING_LEN_MAX], pwd[SAT_TEXT_STRING_LEN_MAX];
2007
2008                         memset(&network_access_name, 0 , SAT_NET_ACC_NAM_LEN_MAX);
2009                         memset(&other_address, 0 , SAT_OTHER_ADDR_LEN_MAX);
2010                         memset(&login, 0 , SAT_TEXT_STRING_LEN_MAX);
2011                         memset(&pwd, 0 , SAT_TEXT_STRING_LEN_MAX);
2012
2013                         //bearer parameter
2014                         precedence_class = open_channel_tlv->bearer_desc.bearer_parameter.ps_bearer_param.precedence_class;
2015                         delay_class = open_channel_tlv->bearer_desc.bearer_parameter.ps_bearer_param.delay_class;
2016                         reliability_class = open_channel_tlv->bearer_desc.bearer_parameter.ps_bearer_param.reliability_class;
2017                         peak_class = open_channel_tlv->bearer_desc.bearer_parameter.ps_bearer_param.peak_throughput_class;
2018                         mean_class = open_channel_tlv->bearer_desc.bearer_parameter.ps_bearer_param.mean_throughput_class;
2019                         pdp_type = open_channel_tlv->bearer_desc.bearer_parameter.ps_bearer_param.pdp_type;
2020
2021                         bearer_param = g_variant_new("(iiiiii)", precedence_class, delay_class, reliability_class, peak_class, mean_class, pdp_type);
2022
2023                         memcpy(network_access_name, open_channel_tlv->bearer_detail.ps_bearer.network_access_name.network_access_name,
2024                                         open_channel_tlv->bearer_detail.ps_bearer.network_access_name.length);
2025                         other_addr_type = open_channel_tlv->bearer_detail.ps_bearer.other_address.address_type;
2026                         memcpy(other_address, open_channel_tlv->bearer_detail.ps_bearer.other_address.address, open_channel_tlv->bearer_detail.ps_bearer.other_address.address_len);
2027
2028                         tcore_util_convert_string_to_utf8((unsigned char*) &login, (unsigned short *) &login_len,
2029                                         open_channel_tlv->bearer_detail.ps_bearer.text_user_login.dcs.a_format,
2030                                         (unsigned char*) &open_channel_tlv->bearer_detail.ps_bearer.text_user_login.string,
2031                                         (unsigned short) open_channel_tlv->bearer_detail.ps_bearer.text_user_login.string_length);
2032
2033                         tcore_util_convert_string_to_utf8((unsigned char*) &pwd, (unsigned short *) &pwd_len,
2034                                         open_channel_tlv->bearer_detail.ps_bearer.text_user_pwd.dcs.a_format,
2035                                         (unsigned char*) &open_channel_tlv->bearer_detail.ps_bearer.text_user_pwd.string,
2036                                         (unsigned short) open_channel_tlv->bearer_detail.ps_bearer.text_user_pwd.string_length);
2037
2038                         bearer_detail= g_variant_new("(sisss)", network_access_name, other_addr_type, other_address, login, pwd);
2039
2040                 } break;
2041                 case BEARER_DEFAULT_BEARER_FROM_TRANSPORT_LAYER:{
2042                         //bearer param
2043
2044                         //bearer detail
2045                         gint other_addr_type = 0;
2046                         gushort login_len = 0, pwd_len = 0;
2047                         gchar other_address[SAT_OTHER_ADDR_LEN_MAX];
2048                         gchar login[SAT_TEXT_STRING_LEN_MAX], pwd[SAT_TEXT_STRING_LEN_MAX];
2049
2050                         memset(&other_address, 0 , SAT_OTHER_ADDR_LEN_MAX);
2051                         memset(&login, 0 , SAT_TEXT_STRING_LEN_MAX);
2052                         memset(&pwd, 0 , SAT_TEXT_STRING_LEN_MAX);
2053
2054                         //bearer parameter
2055                         bearer_param = g_variant_new("()");
2056
2057                         other_addr_type = open_channel_tlv->bearer_detail.default_bearer.other_address.address_type;
2058                         memcpy(other_address, open_channel_tlv->bearer_detail.default_bearer.other_address.address, open_channel_tlv->bearer_detail.default_bearer.other_address.address_len);
2059
2060                         tcore_util_convert_string_to_utf8((unsigned char*) &login, (unsigned short *) &login_len,
2061                                         open_channel_tlv->bearer_detail.default_bearer.text_user_login.dcs.a_format,
2062                                         (unsigned char*) &open_channel_tlv->bearer_detail.default_bearer.text_user_login.string,
2063                                         (unsigned short) open_channel_tlv->bearer_detail.default_bearer.text_user_login.string_length);
2064
2065                         tcore_util_convert_string_to_utf8((unsigned char*) &pwd, (unsigned short *) &pwd_len,
2066                                         open_channel_tlv->bearer_detail.default_bearer.text_user_pwd.dcs.a_format,
2067                                         (unsigned char*) &open_channel_tlv->bearer_detail.default_bearer.text_user_pwd.string,
2068                                         (unsigned short) open_channel_tlv->bearer_detail.default_bearer.text_user_pwd.string_length);
2069
2070                         bearer_detail= g_variant_new("(isss)", other_addr_type, other_address, login, pwd);
2071
2072                 } break;
2073                 case BEARER_LOCAL_LINK_TECHNOLOGY_INDEPENDENT:{
2074                         //bearer param
2075
2076                         //bearer detail
2077                         gushort pwd_len = 0;
2078                         gint remote_address_type =0, time_duration1 = 0, time_duration2 = 0;
2079                         gchar remote_address[SAT_REMOTE_ENTITY_ADDR_LEN_MAX];
2080                         gchar pwd[SAT_TEXT_STRING_LEN_MAX];
2081
2082                         memset(&remote_address, 0 , SAT_REMOTE_ENTITY_ADDR_LEN_MAX);
2083                         memset(&pwd, 0 , SAT_TEXT_STRING_LEN_MAX);
2084
2085                         //bearer parameter
2086                         bearer_param = g_variant_new("()");
2087
2088                         time_duration1 = _get_time_in_ms(&open_channel_tlv->bearer_detail.local_bearer.duration1);
2089                         time_duration2 = _get_time_in_ms(&open_channel_tlv->bearer_detail.local_bearer.duration2);
2090
2091                         tcore_util_convert_string_to_utf8((unsigned char*) &pwd, (unsigned short *) &pwd_len,
2092                                                                                         open_channel_tlv->bearer_detail.default_bearer.text_user_pwd.dcs.a_format,
2093                                                                                         (unsigned char*) &open_channel_tlv->bearer_detail.default_bearer.text_user_pwd.string,
2094                                                                                         (unsigned short) open_channel_tlv->bearer_detail.default_bearer.text_user_pwd.string_length);
2095
2096                         remote_address_type = open_channel_tlv->bearer_detail.local_bearer.remote_entity_address.coding_type;
2097                         memcpy(remote_address, open_channel_tlv->bearer_detail.local_bearer.remote_entity_address.remote_entity_address, open_channel_tlv->bearer_detail.local_bearer.remote_entity_address.length);
2098
2099                         bearer_detail= g_variant_new("(iisis)", time_duration1, time_duration2, pwd, remote_address_type, remote_address);
2100
2101                 } break;
2102                 default:
2103                         dbg("invalid bearer data");
2104                         return NULL;
2105         }//end of switch
2106
2107         //enqueue data and generate cmd_id
2108         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
2109         q_data.cmd_type = SAT_PROATV_CMD_OPEN_CHANNEL;
2110         q_data.cp_name = g_strdup(cp_name);
2111         memcpy((void*)&(q_data.cmd_data.open_channel), open_channel_tlv, sizeof(struct tel_sat_open_channel_tlv));
2112         if(FALSE == sat_manager_enqueue_cmd(ctx, &q_data)){
2113                 g_free(q_data.cp_name);
2114         }
2115         command_id = q_data.cmd_id;
2116
2117 #if defined(TIZEN_SUPPORT_STK_HIDE_ALPHA_ID)
2118                 dbg("orange request - do not show the popup");
2119                 _sat_manager_handle_open_channel_confirm(ctx, plg, command_id, USER_CONFIRM_YES, NULL);
2120                 return open_channel;
2121 #endif
2122
2123 #if defined(TIZEN_SUPPORT_SAT_ICON)
2124         /* Icon data extraction */
2125         g_variant_builder_init(&v_builder_icon, G_VARIANT_TYPE ("a(biiiiiis)"));
2126         if(open_channel_tlv->icon_id.is_exist) {
2127                 g_variant_builder_add(&v_builder_icon, "(biiiiiis)", open_channel_tlv->icon_id.is_exist, open_channel_tlv->icon_id.icon_qualifer, (gint32) open_channel_tlv->icon_id.icon_identifier, (gint32) open_channel_tlv->icon_id.icon_info.width,
2128                                         (gint32) open_channel_tlv->icon_id.icon_info.height, open_channel_tlv->icon_id.icon_info.ics, open_channel_tlv->icon_id.icon_info.icon_data_len, open_channel_tlv->icon_id.icon_info.icon_file);
2129         }
2130         icon_id = g_variant_builder_end(&v_builder_icon);
2131         //execute bip
2132         //sat_ui_support_exec_bip();
2133
2134         open_channel = g_variant_new("(isivbbbiviiiisv)", command_id, text, text_len, icon_id, immediate_link, auto_reconnection, bg_mode,
2135                         bearer_type, bearer_param, buffer_size, protocol_type, port_number, dest_addr_type, dest_address, bearer_detail);
2136 #else
2137         open_channel = g_variant_new("(isibbbiviiiisv)", command_id, text, text_len, immediate_link, auto_reconnection, bg_mode,
2138                         bearer_type, bearer_param, buffer_size, protocol_type, port_number, dest_addr_type, dest_address, bearer_detail);
2139 #endif
2140         return open_channel;
2141 }
2142
2143 GVariant* sat_manager_close_channel_noti(struct custom_data *ctx, const char *cp_name, struct tel_sat_close_channel_tlv *close_channel_tlv)
2144 {
2145         TcorePlugin *plg = NULL;
2146         GVariant *close_channel = NULL;
2147         struct sat_manager_queue_data q_data;
2148
2149         gint command_id = 0, channel_id = 0;
2150         gushort text_len = 0;
2151         gchar text[SAT_ALPHA_ID_LEN_MAX];
2152 #if defined(TIZEN_SUPPORT_SAT_ICON)
2153         GVariant *icon_id = NULL;
2154         GVariantBuilder v_builder_icon;
2155 #endif
2156         dbg("interpreting close channel notification");
2157         memset(&text, 0 , SAT_ALPHA_ID_LEN_MAX);
2158
2159         plg = tcore_server_find_plugin(ctx->server, cp_name);
2160         if (!plg){
2161                 dbg("there is no valid plugin at this point");
2162                 return NULL;
2163         }
2164
2165         //channel id
2166         channel_id = close_channel_tlv->device_id.dest;
2167
2168         //close channel text
2169         if(close_channel_tlv->alpha_id.is_exist && close_channel_tlv->alpha_id.alpha_data_len > 0)
2170                 tcore_util_convert_string_to_utf8((unsigned char*)&text,(unsigned short *)&text_len,
2171                                 close_channel_tlv->alpha_id.dcs.a_format,
2172                                 (unsigned char*)&close_channel_tlv->alpha_id.alpha_data,
2173                                 (unsigned short)close_channel_tlv->alpha_id.alpha_data_len);
2174         dbg("close channel text(%s)",text);
2175
2176         //enqueue data and generate cmd_id
2177         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
2178         q_data.cmd_type = SAT_PROATV_CMD_CLOSE_CHANNEL;
2179         q_data.cp_name = g_strdup(cp_name);
2180         memcpy((void*)&(q_data.cmd_data.close_channel), close_channel_tlv, sizeof(struct tel_sat_close_channel_tlv));
2181         if(FALSE == sat_manager_enqueue_cmd(ctx, &q_data)){
2182                 g_free(q_data.cp_name);
2183         }
2184         command_id = q_data.cmd_id;
2185
2186 #if defined(TIZEN_SUPPORT_SAT_ICON)
2187         /* Icon data extraction */
2188         g_variant_builder_init(&v_builder_icon, G_VARIANT_TYPE ("a(biiiiiis)"));
2189         if(close_channel_tlv->icon_id.is_exist) {
2190                 g_variant_builder_add(&v_builder_icon, "(biiiiiis)", close_channel_tlv->icon_id.is_exist, close_channel_tlv->icon_id.icon_qualifer, (gint32) close_channel_tlv->icon_id.icon_identifier, (gint32) close_channel_tlv->icon_id.icon_info.width,
2191                                         (gint32) close_channel_tlv->icon_id.icon_info.height, close_channel_tlv->icon_id.icon_info.ics, close_channel_tlv->icon_id.icon_info.icon_data_len, close_channel_tlv->icon_id.icon_info.icon_file);
2192         }
2193         icon_id = g_variant_builder_end(&v_builder_icon);
2194
2195         close_channel = g_variant_new("(isivi)", command_id, text, text_len, icon_id, channel_id);
2196 #else
2197         close_channel = g_variant_new("(isii)", command_id, text, text_len, channel_id);
2198 #endif
2199         return close_channel;
2200 }
2201
2202 GVariant* sat_manager_receive_data_noti(struct custom_data *ctx, const char *cp_name, struct tel_sat_receive_channel_tlv *receive_data_tlv)
2203 {
2204         TcorePlugin *plg = NULL;
2205         GVariant *receive_data = NULL;
2206         struct sat_manager_queue_data q_data;
2207
2208         gint command_id = 0, channel_id = 0;
2209         gushort text_len = 0;
2210         gint channel_data_len = 0;
2211         gchar text[SAT_ALPHA_ID_LEN_MAX];
2212 #if defined(TIZEN_SUPPORT_SAT_ICON)
2213         GVariant *icon_id = NULL;
2214         GVariantBuilder v_builder_icon;
2215 #endif
2216         dbg("interpreting receive data notification");
2217         memset(&text, 0 , SAT_ALPHA_ID_LEN_MAX);
2218
2219         plg = tcore_server_find_plugin(ctx->server, cp_name);
2220         if (!plg){
2221                 dbg("there is no valid plugin at this point");
2222                 return NULL;
2223         }
2224
2225         //channel id
2226         channel_id = receive_data_tlv->device_id.dest;
2227
2228         //receive data text
2229         if(receive_data_tlv->alpha_id.is_exist && receive_data_tlv->alpha_id.alpha_data_len > 0)
2230                 tcore_util_convert_string_to_utf8((unsigned char*)&text,(unsigned short *)&text_len,
2231                                 receive_data_tlv->alpha_id.dcs.a_format,
2232                                 (unsigned char*)&receive_data_tlv->alpha_id.alpha_data,
2233                                 (unsigned short)receive_data_tlv->alpha_id.alpha_data_len);
2234         dbg("receive data text(%s)",text);
2235
2236         channel_data_len = receive_data_tlv->channel_data_len.data_len;
2237
2238         //enqueue data and generate cmd_id
2239         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
2240         q_data.cmd_type = SAT_PROATV_CMD_RECEIVE_DATA;
2241         q_data.cp_name = g_strdup(cp_name);
2242         memcpy((void*)&(q_data.cmd_data.receive_data), receive_data_tlv, sizeof(struct tel_sat_receive_channel_tlv));
2243         if(FALSE == sat_manager_enqueue_cmd(ctx, &q_data)){
2244                 g_free(q_data.cp_name);
2245         }
2246         command_id = q_data.cmd_id;
2247
2248 #if defined(TIZEN_SUPPORT_SAT_ICON)
2249         /* Icon data extraction */
2250         g_variant_builder_init(&v_builder_icon, G_VARIANT_TYPE ("a(biiiiiis)"));
2251         if(receive_data_tlv->icon_id.is_exist) {
2252                 g_variant_builder_add(&v_builder_icon, "(biiiiiis)", receive_data_tlv->icon_id.is_exist, receive_data_tlv->icon_id.icon_qualifer, (gint32) receive_data_tlv->icon_id.icon_identifier, (gint32) receive_data_tlv->icon_id.icon_info.width,
2253                                         (gint32) receive_data_tlv->icon_id.icon_info.height, receive_data_tlv->icon_id.icon_info.ics, receive_data_tlv->icon_id.icon_info.icon_data_len, receive_data_tlv->icon_id.icon_info.icon_file);
2254         }
2255         icon_id = g_variant_builder_end(&v_builder_icon);
2256
2257         receive_data = g_variant_new("(isivii)", command_id, text, text_len, icon_id, channel_id, channel_data_len);
2258 #else
2259         receive_data = g_variant_new("(isiii)", command_id, text, text_len, channel_id, channel_data_len);
2260 #endif
2261         return receive_data;
2262 }
2263
2264 GVariant* sat_manager_send_data_noti(struct custom_data *ctx, const char *cp_name, struct tel_sat_send_channel_tlv *send_data_tlv)
2265 {
2266         TcorePlugin *plg = NULL;
2267         GVariant *send_data = NULL;
2268         struct sat_manager_queue_data q_data;
2269
2270         int local_index = 0;
2271         gint command_id = 0, channel_id = 0, data_len = 0;
2272         gboolean send_data_immediately = FALSE;
2273         gushort text_len = 0;
2274         gchar text[SAT_ALPHA_ID_LEN_MAX];
2275         GVariantBuilder builder;
2276         GVariant *channel_data = NULL;
2277 #if defined(TIZEN_SUPPORT_SAT_ICON)
2278         GVariant *icon_id = NULL;
2279         GVariantBuilder v_builder_icon;
2280 #endif
2281         dbg("interpreting send data notification");
2282         memset(&text, 0 , SAT_ALPHA_ID_LEN_MAX);
2283
2284         plg = tcore_server_find_plugin(ctx->server, cp_name);
2285         if (!plg){
2286                 dbg("there is no valid plugin at this point");
2287                 return NULL;
2288         }
2289
2290         //send data immediately
2291         send_data_immediately = send_data_tlv->command_detail.cmd_qualifier.send_data.send_data_immediately;
2292
2293         //channel id
2294         channel_id = send_data_tlv->device_id.dest;
2295
2296         //send data text
2297         if(send_data_tlv->alpha_id.is_exist && send_data_tlv->alpha_id.alpha_data_len > 0)
2298                 tcore_util_convert_string_to_utf8((unsigned char*)&text,(unsigned short *)&text_len,
2299                                 send_data_tlv->alpha_id.dcs.a_format,
2300                                 (unsigned char*)&send_data_tlv->alpha_id.alpha_data,
2301                                 (unsigned short)send_data_tlv->alpha_id.alpha_data_len);
2302         dbg("send data text(%s)",text);
2303
2304         //channel data, data len
2305         data_len = send_data_tlv->channel_data.data_string_len;
2306         g_variant_builder_init(&builder, G_VARIANT_TYPE ("ay"));
2307         for (local_index = 0; local_index < data_len; local_index++) {
2308                 //dbg("send data index(%d) data(0x%x)",index, send_data_tlv->channel_data.data_string[index]);
2309                 g_variant_builder_add(&builder, "y", send_data_tlv->channel_data.data_string[local_index]);
2310         }
2311         channel_data = g_variant_builder_end(&builder);
2312
2313         //enqueue data and generate cmd_id
2314         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
2315         q_data.cmd_type = SAT_PROATV_CMD_SEND_DATA;
2316         q_data.cp_name = g_strdup(cp_name);
2317         memcpy((void*)&(q_data.cmd_data.send_data), send_data_tlv, sizeof(struct tel_sat_send_channel_tlv));
2318         if(FALSE == sat_manager_enqueue_cmd(ctx, &q_data)){
2319                 g_free(q_data.cp_name);
2320         }
2321         command_id = q_data.cmd_id;
2322
2323 #if defined(TIZEN_SUPPORT_SAT_ICON)
2324         /* Icon data extraction */
2325         g_variant_builder_init(&v_builder_icon, G_VARIANT_TYPE ("a(biiiiiis)"));
2326         if(send_data_tlv->icon_id.is_exist) {
2327                 g_variant_builder_add(&v_builder_icon, "(biiiiiis)", send_data_tlv->icon_id.is_exist, send_data_tlv->icon_id.icon_qualifer, (gint32) send_data_tlv->icon_id.icon_identifier, (gint32) send_data_tlv->icon_id.icon_info.width,
2328                                         (gint32) send_data_tlv->icon_id.icon_info.height, send_data_tlv->icon_id.icon_info.ics, send_data_tlv->icon_id.icon_info.icon_data_len, send_data_tlv->icon_id.icon_info.icon_file);
2329         }
2330         icon_id = g_variant_builder_end(&v_builder_icon);
2331
2332         send_data = g_variant_new("(isivibvi)", command_id, text, text_len, icon_id, channel_id, send_data_immediately, channel_data, data_len);
2333 #else
2334         send_data = g_variant_new("(isiibvi)", command_id, text, text_len, channel_id, send_data_immediately, channel_data, data_len);
2335 #endif
2336         return send_data;
2337 }
2338
2339 GVariant* sat_manager_get_channel_status_noti(struct custom_data *ctx, const char *cp_name, struct tel_sat_get_channel_status_tlv *get_channel_status_tlv)
2340 {
2341         TcorePlugin *plg = NULL;
2342         GVariant *get_channel_status = NULL;
2343         struct sat_manager_queue_data q_data;
2344
2345         gint command_id = 0;
2346
2347         dbg("interpreting get channel status notification");
2348
2349         plg = tcore_server_find_plugin(ctx->server, cp_name);
2350         if (!plg){
2351                 dbg("there is no valid plugin at this point");
2352                 return NULL;
2353         }
2354
2355         //enqueue data and generate cmd_id
2356         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
2357         q_data.cmd_type = SAT_PROATV_CMD_GET_CHANNEL_STATUS;
2358         q_data.cp_name = g_strdup(cp_name);
2359         memcpy((void*)&(q_data.cmd_data.get_channel_status), get_channel_status_tlv, sizeof(struct tel_sat_get_channel_status_tlv));
2360         if(FALSE == sat_manager_enqueue_cmd(ctx, &q_data)){
2361                 g_free(q_data.cp_name);
2362         }
2363         command_id = q_data.cmd_id;
2364
2365         get_channel_status = g_variant_new("(i)", command_id);
2366
2367         return get_channel_status;
2368 }
2369
2370 GVariant* sat_manager_refresh_noti(struct custom_data *ctx, const char *cp_name, struct tel_sat_refresh_tlv *refresh_tlv)
2371 {
2372         TcorePlugin *plg = NULL;
2373         GVariant *refresh = NULL;
2374 #if !defined(TIZEN_SUPPORT_STK_HIDE_ALPHA_ID)
2375         struct sat_manager_queue_data q_data;
2376 #endif
2377
2378         gint command_id = 0;
2379         gint refresh_type =0;
2380         GVariantBuilder builder;
2381         GVariant *file_list = NULL;
2382         int local_index = 0;
2383
2384         dbg("interpreting refresh notification");
2385
2386         plg = tcore_server_find_plugin(ctx->server, cp_name);
2387         if (!plg){
2388                 dbg("there is no valid plugin at this point");
2389                 return NULL;
2390         }
2391
2392         refresh_type = refresh_tlv->command_detail.cmd_qualifier.refresh.refresh;
2393
2394         if(refresh_type != SIM_REFRESH_CMD_FCN) {
2395                 dbg("reset event list.");
2396                 memset(g_evt_list, 0, SAT_EVENT_DOWNLOAD_MAX);
2397         }
2398
2399         g_variant_builder_init(&builder, G_VARIANT_TYPE ("ai"));
2400         for (local_index = 0; local_index < refresh_tlv->file_list.file_count; local_index++) {
2401                 g_variant_builder_add(&builder, "i", refresh_tlv->file_list.file_id[local_index]);
2402         }
2403         file_list = g_variant_builder_end(&builder);
2404
2405         //enqueue data and generate cmd_id
2406 #if !defined(TIZEN_SUPPORT_STK_HIDE_ALPHA_ID)
2407                 memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
2408                 q_data.cmd_type = SAT_PROATV_CMD_REFRESH;
2409                 q_data.cp_name = g_strdup(cp_name);
2410                 memcpy((void*)&(q_data.cmd_data.refresh), refresh_tlv, sizeof(struct tel_sat_refresh_tlv));
2411                 if(FALSE == sat_manager_enqueue_cmd(ctx, &q_data)){
2412                         g_free(q_data.cp_name);
2413                 }
2414                 command_id = q_data.cmd_id;
2415 #endif
2416
2417         refresh = g_variant_new("(iiv)", command_id, refresh_type, file_list);
2418
2419         return refresh;
2420 }
2421
2422 void sat_manager_more_time_noti(struct custom_data *ctx, const char *cp_name, struct tel_sat_more_time_tlv *more_time_tlv)
2423 {
2424         TcorePlugin *plg = NULL;
2425         struct treq_sat_terminal_rsp_data *tr = NULL;
2426
2427         dbg("interpreting more time notification");
2428
2429         plg = tcore_server_find_plugin(ctx->server, cp_name);
2430         if (!plg){
2431                 dbg("there is no valid plugin at this point");
2432                 return;
2433         }
2434
2435         //send TR - does not need from application's response
2436         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
2437         if (!tr)
2438                 return;
2439
2440         tr->cmd_number = more_time_tlv->command_detail.cmd_num;
2441         tr->cmd_type = more_time_tlv->command_detail.cmd_type;
2442         memcpy((void*)&tr->terminal_rsp_data.more_time.command_detail, &more_time_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
2443         tr->terminal_rsp_data.more_time.device_id.src = more_time_tlv->device_id.dest;
2444         tr->terminal_rsp_data.more_time.device_id.dest = more_time_tlv->device_id.src;
2445         tr->terminal_rsp_data.more_time.result_type = RESULT_SUCCESS;
2446         tr->terminal_rsp_data.more_time.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
2447
2448         sat_manager_send_terminal_response(ctx->comm, plg, tr);
2449         g_free(tr);
2450
2451         return;
2452 }
2453
2454 GVariant* sat_manager_send_dtmf_noti(struct custom_data *ctx, const char *cp_name, struct tel_sat_send_dtmf_tlv *send_dtmf_tlv)
2455 {
2456         TcorePlugin *plg = NULL;
2457         CoreObject *co_call = NULL;
2458         GSList* call_active_list = NULL;
2459
2460         GVariant *send_dtmf = NULL;
2461         struct sat_manager_queue_data q_data;
2462
2463         gint command_id = 0;
2464         gushort text_len =0;
2465         gint dtmf_str_len =0;
2466         gchar text[SAT_TEXT_STRING_LEN_MAX], dtmf_str[SAT_DTMF_STRING_LEN_MAX];
2467 #if defined(TIZEN_SUPPORT_SAT_ICON)
2468         GVariant *icon_id = NULL;
2469         GVariantBuilder v_builder_icon;
2470 #endif
2471         dbg("interpreting send dtmf notification");
2472         memset(&text, 0 , SAT_TEXT_STRING_LEN_MAX);
2473         memset(&dtmf_str, 0 , SAT_DTMF_STRING_LEN_MAX);
2474
2475         plg = tcore_server_find_plugin(ctx->server, cp_name);
2476         if (!plg){
2477                 dbg("there is no valid plugin at this point");
2478                 return NULL;
2479         }
2480
2481         co_call = tcore_plugin_ref_core_object(plg, CORE_OBJECT_TYPE_CALL);
2482         if(!co_call){
2483                 struct treq_sat_terminal_rsp_data tr;
2484                 dbg("call object does not exist");
2485
2486                 memset(&tr, 0, sizeof(struct treq_sat_terminal_rsp_data));
2487                 tr.cmd_number = send_dtmf_tlv->command_detail.cmd_num;
2488                 tr.cmd_type = send_dtmf_tlv->command_detail.cmd_type;
2489
2490                 memcpy((void*)&tr.terminal_rsp_data.send_dtmf.command_detail, &send_dtmf_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
2491                 tr.terminal_rsp_data.send_dtmf.device_id.src = DEVICE_ID_ME;
2492                 tr.terminal_rsp_data.send_dtmf.device_id.dest = DEVICE_ID_SIM;
2493                 tr.terminal_rsp_data.send_dtmf.result_type = RESULT_BEYOND_ME_CAPABILITIES;
2494
2495                 sat_manager_send_terminal_response(ctx->comm, plg, &tr);
2496                 return NULL;
2497         }
2498
2499         call_active_list = tcore_call_object_find_by_status(co_call, TCORE_CALL_STATUS_ACTIVE);
2500         if(!call_active_list){
2501                 struct treq_sat_terminal_rsp_data tr;
2502                 dbg("no active call");
2503
2504                 memset(&tr, 0, sizeof(struct treq_sat_terminal_rsp_data));
2505                 tr.cmd_number = send_dtmf_tlv->command_detail.cmd_num;
2506                 tr.cmd_type = send_dtmf_tlv->command_detail.cmd_type;
2507
2508                 memcpy((void*)&tr.terminal_rsp_data.send_dtmf.command_detail, &send_dtmf_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
2509                 tr.terminal_rsp_data.send_dtmf.device_id.src = DEVICE_ID_ME;
2510                 tr.terminal_rsp_data.send_dtmf.device_id.dest = DEVICE_ID_SIM;
2511                 tr.terminal_rsp_data.send_dtmf.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
2512                 tr.terminal_rsp_data.send_dtmf.me_problem_type = ME_PROBLEM_NOT_IN_SPEECH_CALL;
2513
2514                 sat_manager_send_terminal_response(ctx->comm, plg, &tr);
2515                 return NULL;
2516         }
2517         g_slist_free(call_active_list);
2518
2519         //text and text len
2520         if( send_dtmf_tlv->alpha_id.is_exist && send_dtmf_tlv->alpha_id.alpha_data_len){
2521                 tcore_util_convert_string_to_utf8((unsigned char*)&text,(unsigned short *)&text_len,
2522                                 send_dtmf_tlv->alpha_id.dcs.a_format,
2523                                 (unsigned char*)&send_dtmf_tlv->alpha_id.alpha_data,
2524                                 (unsigned short)send_dtmf_tlv->alpha_id.alpha_data_len);
2525                 dbg("send dtmf ui display text (%s)",text);
2526         }
2527
2528         //dtmf string len, dtmf string
2529         dtmf_str_len = send_dtmf_tlv->dtmf_string.dtmf_length;
2530         memcpy(dtmf_str, send_dtmf_tlv->dtmf_string.dtmf_string, SAT_DTMF_STRING_LEN_MAX);
2531
2532         //enqueue data and generate cmd_id
2533         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
2534         q_data.cmd_type = SAT_PROATV_CMD_SEND_DTMF;
2535         q_data.cp_name = g_strdup(cp_name);
2536         memcpy((void*)&(q_data.cmd_data.send_dtmf), send_dtmf_tlv, sizeof(struct tel_sat_send_dtmf_tlv));
2537         if(FALSE == sat_manager_enqueue_cmd(ctx, &q_data)){
2538                 g_free(q_data.cp_name);
2539         }
2540         command_id = q_data.cmd_id;
2541
2542 #if defined(TIZEN_SUPPORT_SAT_ICON)
2543         /* Icon data extraction */
2544         g_variant_builder_init(&v_builder_icon, G_VARIANT_TYPE ("a(biiiiiis)"));
2545         if(send_dtmf_tlv->icon_id.is_exist) {
2546                 g_variant_builder_add(&v_builder_icon, "(biiiiiis)", send_dtmf_tlv->icon_id.is_exist, send_dtmf_tlv->icon_id.icon_qualifer, (gint32) send_dtmf_tlv->icon_id.icon_identifier, (gint32) send_dtmf_tlv->icon_id.icon_info.width,
2547                                         (gint32) send_dtmf_tlv->icon_id.icon_info.height, send_dtmf_tlv->icon_id.icon_info.ics, send_dtmf_tlv->icon_id.icon_info.icon_data_len, send_dtmf_tlv->icon_id.icon_info.icon_file);
2548         }
2549         icon_id = g_variant_builder_end(&v_builder_icon);
2550
2551         send_dtmf = g_variant_new("(isivis)", command_id, text, text_len, icon_id, dtmf_str_len, dtmf_str);
2552 #else
2553         send_dtmf = g_variant_new("(isiis)", command_id, text, text_len, dtmf_str_len, dtmf_str);
2554 #endif
2555         return send_dtmf;
2556 }
2557
2558 GVariant* sat_manager_launch_browser_noti(struct custom_data *ctx, const char *cp_name, struct tel_sat_launch_browser_tlv *launch_browser_tlv)
2559 {
2560         TcorePlugin *plg = NULL;
2561         GVariant *launch_browser = NULL;
2562         struct sat_manager_queue_data q_data;
2563
2564 #if GCF_SAT_BROWSER_WITH_SINGLE_SESSION
2565         gboolean b_app_running = FALSE;
2566 #endif
2567         gint command_id = 0;
2568         gint browser_launch_type = 0, browser_id = 0;
2569         gint url_len =0;
2570         gushort text_len =0, gateway_proxy_len =0;
2571         gchar url[SAT_URL_LEN_MAX], text[SAT_TEXT_STRING_LEN_MAX], gateway_proxy[SAT_TEXT_STRING_LEN_MAX];
2572 #if defined(TIZEN_SUPPORT_SAT_ICON)
2573         GVariant *icon_id = NULL;
2574         GVariantBuilder v_builder_icon;
2575 #endif
2576         dbg("interpreting launch browser notification");
2577         memset(&url, 0 , SAT_URL_LEN_MAX);
2578         memset(&text, 0 , SAT_TEXT_STRING_LEN_MAX);
2579         memset(&gateway_proxy, 0 , SAT_TEXT_STRING_LEN_MAX);
2580
2581         plg = tcore_server_find_plugin(ctx->server, cp_name);
2582         if (!plg){
2583                 dbg("there is no valid plugin at this point");
2584                 return NULL;
2585         }
2586
2587         if(!launch_browser_tlv->user_confirm_alpha_id.is_exist &&
2588                 (launch_browser_tlv->user_confirm_icon_id.is_exist && launch_browser_tlv->user_confirm_icon_id.icon_qualifer != ICON_QUALI_SELF_EXPLANATORY)){
2589                 struct treq_sat_terminal_rsp_data tr;
2590                 dbg("no alpha id and no self explanatory");
2591
2592                 memset(&tr, 0, sizeof(struct treq_sat_terminal_rsp_data));
2593                 tr.cmd_number = launch_browser_tlv->command_detail.cmd_num;
2594                 tr.cmd_type = launch_browser_tlv->command_detail.cmd_type;
2595
2596                 memcpy((void*)&tr.terminal_rsp_data.launch_browser.command_detail, &launch_browser_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
2597                 tr.terminal_rsp_data.launch_browser.device_id.src = DEVICE_ID_ME;
2598                 tr.terminal_rsp_data.launch_browser.device_id.dest = DEVICE_ID_SIM;
2599                 tr.terminal_rsp_data.launch_browser.result_type = RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME;
2600
2601                 sat_manager_send_terminal_response(ctx->comm, plg, &tr);
2602                 return NULL;
2603         }
2604
2605 #if GCF_SAT_BROWSER_WITH_SINGLE_SESSION
2606         b_app_running = sat_ui_check_app_is_running("org.tizen.browser");
2607 #endif
2608         //browser launch type
2609         browser_launch_type = launch_browser_tlv->command_detail.cmd_qualifier.launch_browser.launch_browser;
2610
2611         /* ORA PLM P131004-00081:Launch browser while session already opened.
2612          * Tizen-SAT looks at command qualifier only when ME in GCF mode.
2613          *
2614          * 2013.12.10 : Now, GCF certificate permits device option that "Terminal supports
2615          * browser with multiple sessions/taps" so we don't need GCF feature anymore and
2616          * therefore disabled here.
2617          */
2618 #if GCF_SAT_BROWSER_WITH_SINGLE_SESSION
2619         if(browser_launch_type == LAUNCH_BROWSER_IF_NOT_ALREADY_LAUNCHED && b_app_running){
2620                 struct treq_sat_terminal_rsp_data tr;
2621                 dbg("browser is already running type(%d)", browser_launch_type);
2622
2623                 memset(&tr, 0, sizeof(struct treq_sat_terminal_rsp_data));
2624                 tr.cmd_number = launch_browser_tlv->command_detail.cmd_num;
2625                 tr.cmd_type = launch_browser_tlv->command_detail.cmd_type;
2626
2627                 memcpy((void*)&tr.terminal_rsp_data.launch_browser.command_detail, &launch_browser_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
2628                 tr.terminal_rsp_data.launch_browser.device_id.src = DEVICE_ID_ME;
2629                 tr.terminal_rsp_data.launch_browser.device_id.dest = DEVICE_ID_SIM;
2630                 tr.terminal_rsp_data.launch_browser.result_type = RESULT_LAUNCH_BROWSER_GENERIC_ERROR_CODE;
2631                 tr.terminal_rsp_data.launch_browser.browser_problem_type = BROWSER_PROBLEM_BROWSER_UNAVAILABLE;
2632
2633                 sat_manager_send_terminal_response(ctx->comm, plg, &tr);
2634
2635                 return NULL;
2636         }
2637         else if( (browser_launch_type == LAUNCH_BROWSER_USE_EXISTING_BROWSER || browser_launch_type == LAUNCH_BROWSER_CLOSE_AND_LAUNCH_NEW_BROWSER) && !b_app_running){
2638                 struct treq_sat_terminal_rsp_data tr;
2639                 dbg("browser is not running type(%d)", browser_launch_type);
2640
2641                 memset(&tr, 0, sizeof(struct treq_sat_terminal_rsp_data));
2642                 tr.cmd_number = launch_browser_tlv->command_detail.cmd_num;
2643                 tr.cmd_type = launch_browser_tlv->command_detail.cmd_type;
2644
2645                 memcpy((void*)&tr.terminal_rsp_data.launch_browser.command_detail, &launch_browser_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
2646                 tr.terminal_rsp_data.launch_browser.device_id.src = DEVICE_ID_ME;
2647                 tr.terminal_rsp_data.launch_browser.device_id.dest = DEVICE_ID_SIM;
2648                 tr.terminal_rsp_data.launch_browser.result_type = RESULT_LAUNCH_BROWSER_GENERIC_ERROR_CODE;
2649                 tr.terminal_rsp_data.launch_browser.browser_problem_type = BROWSER_PROBLEM_BROWSER_UNAVAILABLE;
2650
2651                 sat_manager_send_terminal_response(ctx->comm, plg, &tr);
2652
2653                 return NULL;
2654         }
2655 #endif
2656
2657         //browser id
2658         browser_id = launch_browser_tlv->browser_id;
2659
2660         //url and url len
2661         if( launch_browser_tlv->url.url_length){
2662                 url_len = launch_browser_tlv->url.url_length;
2663                 memcpy(url, launch_browser_tlv->url.url, launch_browser_tlv->url.url_length);
2664                 dbg("launch browser url (%s)",url);
2665         }
2666
2667         //gateway_proxy_text
2668         if(launch_browser_tlv->gateway_proxy_text.is_digit_only) {
2669                 memcpy(gateway_proxy, launch_browser_tlv->gateway_proxy_text.string, launch_browser_tlv->gateway_proxy_text.string_length);
2670                 dbg("launch browser gateway_proxy digit type string (%s)",gateway_proxy);
2671         } else {
2672                 if( launch_browser_tlv->gateway_proxy_text.string_length){
2673                         tcore_util_convert_string_to_utf8((unsigned char*)&gateway_proxy,(unsigned short *)&gateway_proxy_len,
2674                                         launch_browser_tlv->gateway_proxy_text.dcs.a_format,
2675                                         (unsigned char*)&launch_browser_tlv->gateway_proxy_text.string,
2676                                         (unsigned short)launch_browser_tlv->gateway_proxy_text.string_length);
2677                         dbg("launch browser gateway_proxy_text (%s)",gateway_proxy);
2678                 }
2679         }
2680
2681         //user confirm text and user confirm text len
2682         if( launch_browser_tlv->user_confirm_alpha_id.is_exist && launch_browser_tlv->user_confirm_alpha_id.alpha_data_len){
2683                 tcore_util_convert_string_to_utf8((unsigned char*)&text,(unsigned short *)&text_len,
2684                                 launch_browser_tlv->user_confirm_alpha_id.dcs.a_format,
2685                                 (unsigned char*)&launch_browser_tlv->user_confirm_alpha_id.alpha_data,
2686                                 (unsigned short)launch_browser_tlv->user_confirm_alpha_id.alpha_data_len);
2687                 dbg("launch browser user confirm text (%s)",text);
2688         }
2689
2690         //enqueue data and generate cmd_id
2691         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
2692         q_data.cmd_type = SAT_PROATV_CMD_LAUNCH_BROWSER;
2693         q_data.cp_name = g_strdup(cp_name);
2694         memcpy((void*)&(q_data.cmd_data.launch_browser), launch_browser_tlv, sizeof(struct tel_sat_launch_browser_tlv));
2695         if(FALSE == sat_manager_enqueue_cmd(ctx, &q_data)){
2696                 g_free(q_data.cp_name);
2697         }
2698         command_id = q_data.cmd_id;
2699
2700 #if defined(TIZEN_SUPPORT_SAT_ICON)
2701         /* Icon data extraction */
2702         g_variant_builder_init(&v_builder_icon, G_VARIANT_TYPE ("a(biiiiiis)"));
2703         if(launch_browser_tlv->user_confirm_icon_id.is_exist) {
2704                 g_variant_builder_add(&v_builder_icon, "(biiiiiis)", launch_browser_tlv->user_confirm_icon_id.is_exist, launch_browser_tlv->user_confirm_icon_id.icon_qualifer, (gint32) launch_browser_tlv->user_confirm_icon_id.icon_identifier, (gint32) launch_browser_tlv->user_confirm_icon_id.icon_info.width,
2705                                         (gint32) launch_browser_tlv->user_confirm_icon_id.icon_info.height, launch_browser_tlv->user_confirm_icon_id.icon_info.ics, launch_browser_tlv->user_confirm_icon_id.icon_info.icon_data_len, launch_browser_tlv->user_confirm_icon_id.icon_info.icon_file);
2706         }
2707         icon_id = g_variant_builder_end(&v_builder_icon);
2708
2709         launch_browser = g_variant_new("(iiisisisiv)",
2710                         command_id, browser_launch_type, browser_id, url, url_len, gateway_proxy, gateway_proxy_len, text, text_len, icon_id);
2711 #else
2712         launch_browser = g_variant_new("(iiisisisi)",
2713                         command_id, browser_launch_type, browser_id, url, url_len, gateway_proxy, gateway_proxy_len, text, text_len);
2714 #endif
2715         return launch_browser;
2716 }
2717
2718 GVariant* sat_manager_provide_local_info_noti(struct custom_data *ctx, const char *cp_name, struct tel_sat_provide_local_info_tlv *provide_local_info_tlv)
2719 {
2720         TcorePlugin *plg = NULL;
2721         GVariant *provide_info = NULL;
2722
2723         gint info_type =0;
2724         struct treq_sat_terminal_rsp_data *tr = NULL;
2725
2726         dbg("interpreting provide local info notification");
2727
2728         plg = tcore_server_find_plugin(ctx->server, cp_name);
2729         if (!plg){
2730                 dbg("there is no valid plugin at this point");
2731                 return NULL;
2732         }
2733
2734         provide_info = g_variant_new("(i)", info_type);
2735
2736         //send TR - does not need from application's response
2737         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
2738         if (!tr)
2739                 return NULL;
2740
2741         tr->cmd_number = provide_local_info_tlv->command_detail.cmd_num;
2742         tr->cmd_type = provide_local_info_tlv->command_detail.cmd_type;
2743         memcpy((void*)&tr->terminal_rsp_data.provide_local_info.command_detail, &provide_local_info_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
2744         tr->terminal_rsp_data.provide_local_info.device_id.src = provide_local_info_tlv->device_id.dest;
2745         tr->terminal_rsp_data.provide_local_info.device_id.dest = provide_local_info_tlv->device_id.src;
2746         tr->terminal_rsp_data.provide_local_info.other_info = TRUE;
2747
2748         info_type = provide_local_info_tlv->command_detail.cmd_qualifier.provide_local_info.provide_local_info;
2749
2750         switch(info_type){
2751                 case LOCAL_INFO_DATE_TIME_AND_TIMEZONE:{
2752                         int err = 0; int gmt = 0, n_flg = 0;
2753                         struct timezone c_tz;
2754                         struct timeval c_time;
2755
2756                         time_t time_val;
2757                         struct tm time_info;
2758
2759                         time(&time_val);
2760
2761                         tzset();
2762                         err = gettimeofday(&c_time, &c_tz);
2763                         localtime_r(&time_val, &time_info);
2764
2765                         //set the time information
2766                         tr->terminal_rsp_data.provide_local_info.other.date_time_and_timezone.year =
2767                                 _convert_decimal_to_bcd(time_info.tm_year+1900-2000);
2768
2769                         tr->terminal_rsp_data.provide_local_info.other.date_time_and_timezone.month =
2770                                         _convert_decimal_to_bcd(time_info.tm_mon+1);
2771
2772                         tr->terminal_rsp_data.provide_local_info.other.date_time_and_timezone.day =
2773                                         _convert_decimal_to_bcd(time_info.tm_mday);
2774
2775                         tr->terminal_rsp_data.provide_local_info.other.date_time_and_timezone.hour =
2776                                         _convert_decimal_to_bcd(time_info.tm_hour);
2777
2778                         tr->terminal_rsp_data.provide_local_info.other.date_time_and_timezone.minute =
2779                                         _convert_decimal_to_bcd(time_info.tm_min);
2780
2781                         tr->terminal_rsp_data.provide_local_info.other.date_time_and_timezone.second =
2782                                         _convert_decimal_to_bcd(time_info.tm_sec);
2783
2784                         gmt = c_tz.tz_minuteswest/60;
2785                         if(gmt < 0){
2786                                 gmt = gmt * -1;
2787                                 n_flg = 1;
2788                         }
2789
2790                         if(err != 0){
2791                                 tr->terminal_rsp_data.provide_local_info.other.date_time_and_timezone.timeZone = 0xFF;
2792                         }
2793                         else{
2794                                 tr->terminal_rsp_data.provide_local_info.other.date_time_and_timezone.timeZone =
2795                                         _convert_decimal_to_bcd(gmt);
2796
2797                                 if(n_flg == 1){
2798                                         tr->terminal_rsp_data.provide_local_info.other.date_time_and_timezone.timeZone += 0x80;
2799                                 }
2800
2801                                 if(time_info.tm_isdst > 0){
2802                                         tr->terminal_rsp_data.provide_local_info.other.date_time_and_timezone.timeZone += 0x40;
2803                                 }
2804                         }
2805
2806                         tr->terminal_rsp_data.provide_local_info.result_type = RESULT_SUCCESS;
2807                         tr->terminal_rsp_data.provide_local_info.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
2808                 } break;
2809                 case LOCAL_INFO_LANGUAGE:{
2810                         Server *s = NULL;
2811                         static Storage *strg;
2812                         gchar *lang_str = NULL;
2813                         enum tel_sim_language_type lang_type = SIM_LANG_UNSPECIFIED;
2814
2815                         tr->terminal_rsp_data.provide_local_info.result_type = RESULT_SUCCESS;
2816                         tr->terminal_rsp_data.provide_local_info.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
2817
2818                         s = ctx->server;
2819                         strg = tcore_server_find_storage(s, "vconf");
2820                         lang_str = tcore_storage_get_string(strg, STORAGE_KEY_LANGUAGE_SET);
2821                         if(lang_str)
2822                                 lang_type = _convert_string_to_sim_lang(lang_str);
2823
2824                         tr->terminal_rsp_data.provide_local_info.other.language = lang_type;
2825                 } break;
2826                 default :{
2827                         tr->terminal_rsp_data.provide_local_info.other_info = FALSE;
2828                         tr->terminal_rsp_data.provide_local_info.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
2829                         tr->terminal_rsp_data.provide_local_info.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
2830                 } break;
2831         }
2832
2833         sat_manager_send_terminal_response(ctx->comm, plg, tr);
2834         g_free(tr);
2835
2836         return provide_info;
2837 }
2838
2839 GVariant* sat_manager_language_notification_noti(struct custom_data *ctx, const char *cp_name, struct tel_sat_language_notification_tlv *language_notification_tlv)
2840 {
2841         TcorePlugin *plg = NULL;
2842         GVariant *language_noti = NULL;
2843         struct sat_manager_queue_data q_data;
2844
2845         gint command_id = 0;
2846         gint language =0;
2847         gboolean b_specified = FALSE;
2848
2849         dbg("interpreting langauge notification");
2850
2851         plg = tcore_server_find_plugin(ctx->server, cp_name);
2852         if (!plg){
2853                 dbg("there is no valid plugin at this point");
2854                 return NULL;
2855         }
2856
2857         if (language_notification_tlv->command_detail.cmd_qualifier.language_notification.specific_language == TRUE){
2858                 b_specified = TRUE;
2859                 language = language_notification_tlv->language;
2860         } else {
2861                 b_specified = FALSE;
2862                 language =SIM_LANG_UNSPECIFIED;
2863         }
2864
2865         //enqueue data and generate cmd_id
2866         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
2867         q_data.cmd_type = SAT_PROATV_CMD_LANGUAGE_NOTIFICATION;
2868         q_data.cp_name = g_strdup(cp_name);
2869         memcpy((void*)&(q_data.cmd_data.language_notification), language_notification_tlv, sizeof(struct tel_sat_language_notification_tlv));
2870         if(FALSE == sat_manager_enqueue_cmd(ctx, &q_data)){
2871                 g_free(q_data.cp_name);
2872         }
2873         command_id = q_data.cmd_id;
2874
2875         language_noti = g_variant_new("(iib)", command_id, language, b_specified);
2876
2877         return language_noti;
2878 }
2879
2880 gboolean sat_manager_processing_unsupport_proactive_command(struct custom_data *ctx, const char *cp_name, struct tel_sat_unsupproted_command_tlv *unsupport_tlv)
2881 {
2882         TcorePlugin *plg = NULL;
2883         struct treq_sat_terminal_rsp_data tr;
2884
2885         dbg("[SAT] unsupport proactive command (%d)", unsupport_tlv->command_detail.cmd_type);
2886
2887         plg = tcore_server_find_plugin(ctx->server, cp_name);
2888         if (!plg){
2889                 dbg("there is no valid plugin at this point");
2890                 return FALSE;
2891         }
2892
2893         memset(&tr, 0x00, sizeof(struct treq_sat_terminal_rsp_data));
2894         tr.cmd_number = unsupport_tlv->command_detail.cmd_num;
2895         tr.cmd_type = unsupport_tlv->command_detail.cmd_type;
2896
2897         memcpy((void*)&tr.terminal_rsp_data.unsupport_cmd.command_detail, &unsupport_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
2898         tr.terminal_rsp_data.unsupport_cmd.device_id.src = DEVICE_ID_ME;
2899         tr.terminal_rsp_data.unsupport_cmd.device_id.dest = DEVICE_ID_SIM;
2900         tr.terminal_rsp_data.unsupport_cmd.result_type = RESULT_BEYOND_ME_CAPABILITIES;
2901
2902         sat_manager_send_terminal_response(ctx->comm, plg, &tr);
2903
2904         return TRUE;
2905 }
2906
2907 gboolean sat_manager_handle_sat_ui_launch_fail(struct custom_data *ctx, const char *cp_name, struct tnoti_sat_proactive_ind *p_ind)
2908 {
2909         TReturn rv = TCORE_RETURN_FAILURE;
2910         TcorePlugin *plg = NULL;
2911         struct treq_sat_terminal_rsp_data tr;
2912
2913         dbg("[SAT] proactive command (%d)", p_ind->cmd_type);
2914
2915         plg = tcore_server_find_plugin(ctx->server, cp_name);
2916         if (!plg){
2917                 dbg("there is no valid plugin at this point");
2918                 return FALSE;
2919         }
2920
2921         memset(&tr, 0x00, sizeof(struct treq_sat_terminal_rsp_data));
2922         tr.cmd_number = p_ind->cmd_number;
2923         tr.cmd_type = p_ind->cmd_type;
2924
2925         switch (p_ind->cmd_type) {
2926                 case SAT_PROATV_CMD_DISPLAY_TEXT: {
2927                         memcpy((void*)&tr.terminal_rsp_data.display_text.command_detail, &p_ind->proactive_ind_data.display_text.command_detail, sizeof(struct tel_sat_cmd_detail_info));
2928                         tr.terminal_rsp_data.display_text.device_id.src = DEVICE_ID_ME;
2929                         tr.terminal_rsp_data.display_text.device_id.dest = DEVICE_ID_SIM;
2930                         tr.terminal_rsp_data.display_text.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
2931                 } break;
2932                 case SAT_PROATV_CMD_SELECT_ITEM: {
2933                         memcpy((void*)&tr.terminal_rsp_data.select_item.command_detail, &p_ind->proactive_ind_data.select_item.command_detail, sizeof(struct tel_sat_cmd_detail_info));
2934                         tr.terminal_rsp_data.select_item.device_id.src = DEVICE_ID_ME;
2935                         tr.terminal_rsp_data.select_item.device_id.dest = DEVICE_ID_SIM;
2936                         tr.terminal_rsp_data.select_item.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
2937                 } break;
2938                 case SAT_PROATV_CMD_GET_INKEY: {
2939                         memcpy((void*)&tr.terminal_rsp_data.get_inkey.command_detail, &p_ind->proactive_ind_data.get_inkey.command_detail, sizeof(struct tel_sat_cmd_detail_info));
2940                         tr.terminal_rsp_data.get_inkey.device_id.src = DEVICE_ID_ME;
2941                         tr.terminal_rsp_data.get_inkey.device_id.dest = DEVICE_ID_SIM;
2942                         tr.terminal_rsp_data.get_inkey.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
2943                 } break;
2944                 case SAT_PROATV_CMD_GET_INPUT: {
2945                         memcpy((void*)&tr.terminal_rsp_data.get_input.command_detail, &p_ind->proactive_ind_data.get_input.command_detail, sizeof(struct tel_sat_cmd_detail_info));
2946                         tr.terminal_rsp_data.get_input.device_id.src = DEVICE_ID_ME;
2947                         tr.terminal_rsp_data.get_input.device_id.dest = DEVICE_ID_SIM;
2948                         tr.terminal_rsp_data.get_input.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
2949                 } break;
2950                 case SAT_PROATV_CMD_PLAY_TONE: {
2951                         memcpy((void*)&tr.terminal_rsp_data.play_tone.command_detail, &p_ind->proactive_ind_data.play_tone.command_detail, sizeof(struct tel_sat_cmd_detail_info));
2952                         tr.terminal_rsp_data.play_tone.device_id.src = DEVICE_ID_ME;
2953                         tr.terminal_rsp_data.play_tone.device_id.dest = DEVICE_ID_SIM;
2954                         tr.terminal_rsp_data.play_tone.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
2955                 } break;
2956                 case SAT_PROATV_CMD_SEND_SMS: {
2957                         memcpy((void*)&tr.terminal_rsp_data.send_sms.command_detail, &p_ind->proactive_ind_data.send_sms.command_detail, sizeof(struct tel_sat_cmd_detail_info));
2958                         tr.terminal_rsp_data.send_sms.device_id.src = DEVICE_ID_ME;
2959                         tr.terminal_rsp_data.send_sms.device_id.dest = DEVICE_ID_SIM;
2960                         tr.terminal_rsp_data.send_sms.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
2961                 } break;
2962                 case SAT_PROATV_CMD_SEND_SS: {
2963                         memcpy((void*)&tr.terminal_rsp_data.send_ss.command_detail, &p_ind->proactive_ind_data.send_ss.command_detail, sizeof(struct tel_sat_cmd_detail_info));
2964                         tr.terminal_rsp_data.send_ss.device_id.src = DEVICE_ID_ME;
2965                         tr.terminal_rsp_data.send_ss.device_id.dest = DEVICE_ID_SIM;
2966                         tr.terminal_rsp_data.send_ss.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
2967                 } break;
2968                 case SAT_PROATV_CMD_SEND_USSD: {
2969                         memcpy((void*)&tr.terminal_rsp_data.send_ussd.command_detail, &p_ind->proactive_ind_data.send_ussd.command_detail, sizeof(struct tel_sat_cmd_detail_info));
2970                         tr.terminal_rsp_data.send_ussd.device_id.src = DEVICE_ID_ME;
2971                         tr.terminal_rsp_data.send_ussd.device_id.dest = DEVICE_ID_SIM;
2972                         tr.terminal_rsp_data.send_ussd.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
2973                 } break;
2974                 case SAT_PROATV_CMD_SETUP_CALL: {
2975                         memcpy((void*)&tr.terminal_rsp_data.setup_call.command_detail, &p_ind->proactive_ind_data.setup_call.command_detail, sizeof(struct tel_sat_cmd_detail_info));
2976                         tr.terminal_rsp_data.setup_call.device_id.src = DEVICE_ID_ME;
2977                         tr.terminal_rsp_data.setup_call.device_id.dest = DEVICE_ID_SIM;
2978                         tr.terminal_rsp_data.setup_call.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
2979                 } break;
2980                 case SAT_PROATV_CMD_SETUP_IDLE_MODE_TEXT: {
2981                         memcpy((void*)&tr.terminal_rsp_data.setup_idle_mode_text.command_detail, &p_ind->proactive_ind_data.setup_idle_mode_text.command_detail, sizeof(struct tel_sat_cmd_detail_info));
2982                         tr.terminal_rsp_data.setup_idle_mode_text.device_id.src = DEVICE_ID_ME;
2983                         tr.terminal_rsp_data.setup_idle_mode_text.device_id.dest = DEVICE_ID_SIM;
2984                         tr.terminal_rsp_data.setup_idle_mode_text.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
2985                 } break;
2986                 case SAT_PROATV_CMD_OPEN_CHANNEL: {
2987                         memcpy((void*)&tr.terminal_rsp_data.open_channel.command_detail, &p_ind->proactive_ind_data.open_channel.command_detail, sizeof(struct tel_sat_cmd_detail_info));
2988                         tr.terminal_rsp_data.open_channel.device_id.src = DEVICE_ID_ME;
2989                         tr.terminal_rsp_data.open_channel.device_id.dest = DEVICE_ID_SIM;
2990                         tr.terminal_rsp_data.open_channel.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
2991                 } break;
2992                 case SAT_PROATV_CMD_LAUNCH_BROWSER: {
2993                         memcpy((void*)&tr.terminal_rsp_data.launch_browser.command_detail, &p_ind->proactive_ind_data.launch_browser.command_detail, sizeof(struct tel_sat_cmd_detail_info));
2994                         tr.terminal_rsp_data.launch_browser.device_id.src = DEVICE_ID_ME;
2995                         tr.terminal_rsp_data.launch_browser.device_id.dest = DEVICE_ID_SIM;
2996                         tr.terminal_rsp_data.launch_browser.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
2997                 } break;
2998                 default:
2999                         dbg("unsupported command.");
3000                         break;
3001         }
3002
3003         rv = sat_manager_send_terminal_response(ctx->comm, plg, &tr);
3004         if(rv != TCORE_RETURN_SUCCESS)
3005                 return FALSE;
3006
3007         return TRUE;
3008 }
3009
3010 static gboolean _sat_manager_handle_setup_menu_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
3011 {
3012         TReturn rv = TCORE_RETURN_FAILURE;
3013         gboolean result = FALSE;
3014
3015         gint resp;
3016         struct treq_sat_terminal_rsp_data *tr;
3017         struct sat_manager_queue_data q_data;
3018
3019         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
3020
3021         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
3022                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
3023                 return result;
3024         }
3025
3026         if(!exec_result){
3027                 dbg("[SAT] setup menu result data is null");
3028                 return result;
3029         }
3030
3031         if (!plg){
3032                 dbg("there is no valid plugin at this point");
3033                 return result;
3034         }
3035
3036         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
3037         g_variant_get(exec_result, "(i)", &resp);
3038
3039         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
3040         if (!tr)
3041                 return result;
3042
3043         tr->cmd_number = q_data.cmd_data.setupMenuInd.command_detail.cmd_num;
3044         tr->cmd_type = q_data.cmd_data.setupMenuInd.command_detail.cmd_type;
3045
3046         memcpy((void*)&tr->terminal_rsp_data.setup_menu.command_detail,
3047                 &q_data.cmd_data.setupMenuInd.command_detail, sizeof(struct tel_sat_cmd_detail_info));
3048
3049         tr->terminal_rsp_data.setup_menu.device_id.src = q_data.cmd_data.setupMenuInd.device_id.dest;
3050         tr->terminal_rsp_data.setup_menu.device_id.dest = q_data.cmd_data.setupMenuInd.device_id.src;
3051
3052         dbg("[SAT] resp(%d)", resp);
3053
3054         switch(resp){
3055                 case RESULT_SUCCESS:
3056                         tr->terminal_rsp_data.setup_menu.result_type = RESULT_SUCCESS;
3057
3058                         if(q_data.cmd_data.setupMenuInd.text_attribute.b_txt_attr || q_data.cmd_data.setupMenuInd.text_attribute_list.list_cnt > 0)
3059                                 tr->terminal_rsp_data.setup_menu.result_type = RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION;
3060
3061                         if(q_data.cmd_data.setupMenuInd.icon_id.is_exist)
3062                                 tr->terminal_rsp_data.setup_menu.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
3063
3064                         tr->terminal_rsp_data.setup_menu.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3065                         break;
3066
3067                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
3068                         tr->terminal_rsp_data.setup_menu.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
3069                         tr->terminal_rsp_data.setup_menu.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3070                         break;
3071
3072                 default:
3073                         //check the default case
3074                         tr->terminal_rsp_data.setup_menu.result_type = resp;
3075                         tr->terminal_rsp_data.setup_menu.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3076                         dbg("[SAT] wrong result from app exec resp(%d)", resp);
3077                         break;
3078         }
3079
3080         result = TRUE;
3081         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
3082         if(rv != TCORE_RETURN_SUCCESS){
3083                 dbg("fail to send terminal response");
3084                 result = FALSE;
3085         }
3086
3087         g_free(tr);
3088
3089         return result;
3090 }
3091
3092 static gboolean _sat_manager_handle_display_text_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
3093 {
3094         TReturn rv = TCORE_RETURN_FAILURE;
3095         gboolean result = FALSE;
3096
3097         gint resp, me_problem;
3098         struct treq_sat_terminal_rsp_data *tr;
3099         struct sat_manager_queue_data q_data;
3100
3101         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
3102
3103         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
3104                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
3105                 return result;
3106         }
3107
3108         if(!exec_result){
3109                 dbg("[SAT] display text result data is null");
3110                 return result;
3111         }
3112
3113         if (!plg){
3114                 dbg("there is no valid plugin at this point");
3115                 return result;
3116         }
3117
3118         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
3119         g_variant_get(exec_result, "(ii)",&resp, &me_problem);
3120
3121         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
3122         if (!tr)
3123                 return result;
3124
3125         tr->cmd_number = q_data.cmd_data.displayTextInd.command_detail.cmd_num;
3126         tr->cmd_type = q_data.cmd_data.displayTextInd.command_detail.cmd_type;
3127         memcpy((void*)&tr->terminal_rsp_data.display_text.command_detail, &q_data.cmd_data.displayTextInd.command_detail, sizeof(struct tel_sat_cmd_detail_info));
3128         tr->terminal_rsp_data.display_text.device_id.src = DEVICE_ID_ME;
3129         tr->terminal_rsp_data.display_text.device_id.dest = DEVICE_ID_SIM;
3130
3131         switch (resp) {
3132                 case RESULT_SUCCESS:
3133                         tr->terminal_rsp_data.display_text.result_type = RESULT_SUCCESS;
3134
3135                         if(q_data.cmd_data.displayTextInd.text_attribute.b_txt_attr)
3136                                 tr->terminal_rsp_data.display_text.result_type = RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION;
3137
3138                         if (q_data.cmd_data.displayTextInd.icon_id.is_exist)
3139                                 tr->terminal_rsp_data.display_text.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
3140
3141                         tr->terminal_rsp_data.display_text.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3142                         break;
3143
3144                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
3145                         tr->terminal_rsp_data.display_text.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
3146                         tr->terminal_rsp_data.display_text.me_problem_type = me_problem;
3147                         break;
3148
3149                 default:
3150                         tr->terminal_rsp_data.display_text.result_type = resp;
3151                         tr->terminal_rsp_data.display_text.me_problem_type = me_problem;
3152                         dbg("[SAT] wrong result from app exec resp(%d) me_problem(%d)", resp, me_problem);
3153                         break;
3154         }
3155
3156         result = TRUE;
3157         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
3158         if(rv != TCORE_RETURN_SUCCESS){
3159                 dbg("fail to send terminal response");
3160                 result = FALSE;
3161         }
3162
3163         g_free(tr);
3164
3165         return result;
3166 }
3167
3168 static gboolean _sat_manager_handle_play_tone_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
3169 {
3170         TReturn rv = TCORE_RETURN_FAILURE;
3171         gboolean result = FALSE;
3172
3173         gint resp;
3174         struct treq_sat_terminal_rsp_data *tr;
3175         struct sat_manager_queue_data q_data;
3176
3177         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
3178
3179         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
3180                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
3181                 return result;
3182         }
3183
3184         if(!exec_result){
3185                 dbg("[SAT] display text result data is null");
3186                 return result;
3187         }
3188
3189         if (!plg){
3190                 dbg("there is no valid plugin at this point");
3191                 return result;
3192         }
3193
3194         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
3195         g_variant_get(exec_result, "(i)",&resp);
3196
3197         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
3198         if (!tr)
3199                 return result;
3200
3201         tr->cmd_number = q_data.cmd_data.play_tone.command_detail.cmd_num;
3202         tr->cmd_type = q_data.cmd_data.play_tone.command_detail.cmd_type;
3203         memcpy((void*)&tr->terminal_rsp_data.play_tone.command_detail, &q_data.cmd_data.play_tone.command_detail, sizeof(struct tel_sat_cmd_detail_info));
3204         tr->terminal_rsp_data.play_tone.device_id.src = DEVICE_ID_ME;
3205         tr->terminal_rsp_data.play_tone.device_id.dest = DEVICE_ID_SIM;
3206
3207         switch (resp) {
3208                 case RESULT_SUCCESS:
3209                         tr->terminal_rsp_data.play_tone.result_type = RESULT_SUCCESS;
3210
3211                         if(q_data.cmd_data.play_tone.text_attribute.b_txt_attr)
3212                                 tr->terminal_rsp_data.play_tone.result_type = RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION;
3213
3214                         if (q_data.cmd_data.play_tone.icon_id.is_exist)
3215                                 tr->terminal_rsp_data.play_tone.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
3216
3217                         tr->terminal_rsp_data.play_tone.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3218                         break;
3219
3220                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
3221                         tr->terminal_rsp_data.play_tone.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
3222                         tr->terminal_rsp_data.play_tone.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3223                         break;
3224
3225                 case RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER:
3226                         tr->terminal_rsp_data.play_tone.result_type = RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER;
3227                         tr->terminal_rsp_data.play_tone.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3228                         break;
3229
3230                 default:
3231                         tr->terminal_rsp_data.play_tone.result_type = resp;
3232                         tr->terminal_rsp_data.play_tone.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3233                         dbg("[SAT] wrong result from app exec resp(%d)", resp);
3234                         break;
3235         }
3236
3237         result = TRUE;
3238         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
3239         if(rv != TCORE_RETURN_SUCCESS){
3240                 dbg("fail to send terminal response");
3241                 result = FALSE;
3242         }
3243
3244         g_free(tr);
3245         return result;
3246 }
3247
3248 static gboolean _sat_manager_handle_send_sms_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
3249 {
3250         TReturn rv = TCORE_RETURN_FAILURE;
3251         gboolean result = FALSE;
3252
3253         gint resp;
3254         struct treq_sat_terminal_rsp_data *tr;
3255         struct sat_manager_queue_data q_data;
3256
3257         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
3258
3259         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
3260                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
3261                 return result;
3262         }
3263
3264         if(!exec_result){
3265                 dbg("[SAT] send sms data is null");
3266                 return result;
3267         }
3268
3269         if (!plg){
3270                 dbg("there is no valid plugin at this point");
3271                 return result;
3272         }
3273
3274         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
3275         g_variant_get(exec_result, "(i)",&resp);
3276
3277         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
3278         if (!tr)
3279                 return result;
3280
3281         tr->cmd_number = q_data.cmd_data.sendSMSInd.command_detail.cmd_num;
3282         tr->cmd_type = q_data.cmd_data.sendSMSInd.command_detail.cmd_type;
3283         memcpy((void*)&tr->terminal_rsp_data.send_sms.command_detail, &q_data.cmd_data.sendSMSInd.command_detail, sizeof(struct tel_sat_cmd_detail_info));
3284         tr->terminal_rsp_data.send_sms.device_id.src = DEVICE_ID_ME;
3285         tr->terminal_rsp_data.send_sms.device_id.dest = q_data.cmd_data.sendSMSInd.device_id.src;
3286
3287         switch (resp) {
3288                 case RESULT_SUCCESS:
3289                         tr->terminal_rsp_data.send_sms.result_type = RESULT_SUCCESS;
3290                         if (q_data.cmd_data.sendSMSInd.icon_id.is_exist)
3291                                 tr->terminal_rsp_data.send_sms.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
3292
3293                         break;
3294
3295                 case RESULT_INTRCTN_WITH_CC_OR_SMS_CTRL_PRMNT_PRBLM:
3296                         tr->terminal_rsp_data.send_sms.result_type = RESULT_INTRCTN_WITH_CC_OR_SMS_CTRL_PRMNT_PRBLM;
3297                         tr->terminal_rsp_data.send_sms.cc_problem_type = CC_PROBLEM_ACTION_NOT_ALLOWED;
3298                         break;
3299
3300                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
3301                         tr->terminal_rsp_data.send_sms.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
3302                         tr->terminal_rsp_data.send_sms.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3303                         break;
3304
3305                 case RESULT_BEYOND_ME_CAPABILITIES:
3306                         tr->terminal_rsp_data.send_sms.result_type = RESULT_BEYOND_ME_CAPABILITIES;
3307                         tr->terminal_rsp_data.send_sms.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3308                         break;
3309
3310                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
3311                         tr->terminal_rsp_data.send_sms.result_type = RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME;
3312                         tr->terminal_rsp_data.send_sms.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3313                         break;
3314
3315                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
3316                         tr->terminal_rsp_data.send_sms.result_type = RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME;
3317                         tr->terminal_rsp_data.send_sms.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3318                         break;
3319
3320                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
3321                         tr->terminal_rsp_data.send_sms.result_type = RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING;
3322                         tr->terminal_rsp_data.send_sms.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3323                         break;
3324
3325                 case RESULT_SMS_RP_ERROR:
3326                         tr->terminal_rsp_data.send_sms.result_type = RESULT_SMS_RP_ERROR;
3327                         tr->terminal_rsp_data.send_sms.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3328                         break;
3329
3330                 default:
3331                         tr->terminal_rsp_data.send_sms.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
3332                         tr->terminal_rsp_data.send_sms.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3333                         break;
3334         }
3335
3336         result = TRUE;
3337         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
3338         if(rv != TCORE_RETURN_SUCCESS){
3339                 dbg("fail to send terminal response");
3340                 result = FALSE;
3341         }
3342
3343         g_free(tr);
3344
3345 /*      if( q_data.cmd_data.sendSMSInd.alpha_id.alpha_data_len && q_data.cmd_data.sendSMSInd.alpha_id.is_exist)
3346                 sat_ui_support_terminate_sat_ui();*/
3347
3348         return result;
3349 }
3350
3351 static gboolean _sat_manager_handle_send_ss_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
3352 {
3353         TReturn rv = TCORE_RETURN_FAILURE;
3354         gboolean result = FALSE;
3355
3356         gint resp, me_problem, ss_cause, call_ctrl_problem, ss_str_len;
3357         GVariant *ss_str = NULL;
3358         struct treq_sat_terminal_rsp_data *tr;
3359         struct sat_manager_queue_data q_data;
3360         //call ctrl action, result data object, text
3361
3362         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
3363
3364         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
3365                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
3366                 return result;
3367         }
3368
3369         if(!exec_result){
3370                 dbg("[SAT] send ss data is null");
3371                 return result;
3372         }
3373
3374         if (!plg){
3375                 dbg("there is no valid plugin at this point");
3376                 return result;
3377         }
3378
3379         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
3380         g_variant_get(exec_result, "(iii@vii)", &resp, &me_problem, &ss_cause, &ss_str, &ss_str_len, &call_ctrl_problem);
3381
3382         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
3383         if (!tr)
3384                 return result;
3385
3386         tr->cmd_number = q_data.cmd_data.send_ss.command_detail.cmd_num;
3387         tr->cmd_type = q_data.cmd_data.send_ss.command_detail.cmd_type;
3388         memcpy((void*)&tr->terminal_rsp_data.send_ss.command_detail, &q_data.cmd_data.send_ss.command_detail, sizeof(struct tel_sat_cmd_detail_info));
3389         tr->terminal_rsp_data.send_ss.device_id.src = DEVICE_ID_ME;
3390         tr->terminal_rsp_data.send_ss.device_id.dest = q_data.cmd_data.send_ss.device_id.src;
3391
3392         switch (resp) {
3393                 case RESULT_SUCCESS:
3394                         tr->terminal_rsp_data.send_ss.result_type = RESULT_SUCCESS;
3395                         if (q_data.cmd_data.send_ss.icon_id.is_exist)
3396                                 tr->terminal_rsp_data.send_ss.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
3397
3398                         if(ss_str_len > 0 && ss_str){
3399                                 int local_index = 0;
3400                                 guchar data;
3401                                 GVariantIter *iter = NULL;
3402                                 GVariant *intermediate = NULL;
3403                                 char *tmp = NULL;
3404
3405                                 intermediate = g_variant_get_variant(ss_str);
3406                                 dbg("ss string format(%s)", g_variant_get_type_string(intermediate));
3407
3408                                 g_variant_get(intermediate, "ay", &iter);
3409                                 while( g_variant_iter_loop (iter, "y", &data)){
3410                                         dbg("index(%d) data(%c)", local_index, data);
3411                                         tr->terminal_rsp_data.send_ss.text.string[local_index] = data;
3412                                         local_index++;
3413                                 }
3414                                 g_variant_iter_free(iter);
3415                                 g_variant_unref(intermediate);
3416
3417                                 tr->terminal_rsp_data.send_ss.text.string_length = local_index;
3418                                 tmp = _convert_hex_string_to_bytes(tr->terminal_rsp_data.send_ss.text.string);
3419                                 memset(tr->terminal_rsp_data.send_ss.text.string, 0x00,
3420                                         sizeof(tr->terminal_rsp_data.send_ss.text.string));
3421                                 if(tmp) {
3422                                         memcpy(tr->terminal_rsp_data.send_ss.text.string, tmp,
3423                                                 tr->terminal_rsp_data.send_ss.text.string_length);
3424                                         g_free(tmp);
3425                                 }
3426                                 else {
3427                                         err("memcpy failed");
3428                                 }
3429                                 dbg("SS string len:%d", tr->terminal_rsp_data.send_ss.text.string_length);
3430                         }
3431                         break;
3432
3433                 case RESULT_SS_RETURN_ERROR:
3434                         tr->terminal_rsp_data.send_ss.result_type = RESULT_SS_RETURN_ERROR;
3435                         if (ss_cause == SATK_SS_PROBLEM_FACILITY_NOT_SUPPORTED) {
3436                                 tr->terminal_rsp_data.send_ss.ss_problem = SATK_SS_PROBLEM_FACILITY_NOT_SUPPORTED;
3437                         } else {
3438                                 tr->terminal_rsp_data.send_ss.ss_problem = SATK_SS_PROBLEM_NO_SPECIFIC_CAUSE;
3439                         }
3440                         break;
3441
3442                 case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
3443                         tr->terminal_rsp_data.send_ss.result_type = RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND;
3444                         tr->terminal_rsp_data.send_ss.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3445                         break;
3446
3447                 default:
3448                         tr->terminal_rsp_data.send_ss.result_type = RESULT_SS_RETURN_ERROR;
3449                         tr->terminal_rsp_data.send_ss.ss_problem = SATK_SS_PROBLEM_NO_SPECIFIC_CAUSE;
3450                         break;
3451         }
3452
3453         result = TRUE;
3454         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
3455         if(rv != TCORE_RETURN_SUCCESS){
3456                 dbg("fail to send terminal response");
3457                 result = FALSE;
3458         }
3459         g_free(tr);
3460
3461 #if defined(TIZEN_PLATFORM_USE_QCOM_QMI)
3462         if( q_data.cmd_data.send_ss.alpha_id.alpha_data_len && q_data.cmd_data.send_ss.alpha_id.is_exist ) {
3463                 char *path;
3464                 const gchar *cp_name;
3465                 TelephonySAT *sat;
3466                 TelephonyObjectSkeleton *object;
3467
3468                 dbg("AlphaID is present, terminate SAT-UI.");
3469                 cp_name = tcore_server_get_cp_name_by_plugin(plg);
3470                 if (cp_name == NULL) {
3471                         err("CP name is NULL");
3472                         goto Exit;
3473                 }
3474
3475                 dbg("CP Name: [%s]", cp_name);
3476                 path = g_strdup_printf("%s/%s", MY_DBUS_PATH, cp_name);
3477
3478                 /* Look-up Hash table for Object */
3479                 object = g_hash_table_lookup(ctx->objects, path);
3480                 dbg("Path: [%s] Interface object: [%p]", path, object);
3481                 g_free(path);
3482                 if (object == NULL) {
3483                         err("Object is NOT defined!!!");
3484                         goto Exit;
3485                 }
3486
3487                 sat = telephony_object_peek_sat(TELEPHONY_OBJECT(object));
3488                 telephony_sat_emit_end_proactive_session(sat, SAT_PROATV_CMD_TYPE_END_PROACTIVE_SESSION);
3489         }
3490 Exit:
3491 #endif
3492         return result;
3493 }
3494
3495 static gboolean _sat_manager_handle_send_ussd_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
3496 {
3497         TReturn rv = TCORE_RETURN_FAILURE;
3498         gboolean result = FALSE;
3499
3500         gint resp, me_problem, ss_cause, ussd_str_len;
3501         GVariant *ussd_str = NULL;
3502         struct treq_sat_terminal_rsp_data *tr;
3503         struct sat_manager_queue_data q_data;
3504         //call ctrl action, result data object, text, result2, text2
3505
3506         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
3507
3508         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
3509                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
3510                 return result;
3511         }
3512
3513         if(!exec_result){
3514                 dbg("[SAT] send ss data is null");
3515                 return result;
3516         }
3517
3518         if (!plg){
3519                 dbg("there is no valid plugin at this point");
3520                 return result;
3521         }
3522
3523         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
3524         g_variant_get(exec_result, "(iii@vi)", &resp, &me_problem, &ss_cause, &ussd_str, &ussd_str_len);
3525
3526         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
3527         if (!tr)
3528                 return result;
3529
3530         tr->cmd_number = q_data.cmd_data.send_ussd.command_detail.cmd_num;
3531         tr->cmd_type = q_data.cmd_data.send_ussd.command_detail.cmd_type;
3532         memcpy((void*)&tr->terminal_rsp_data.send_ussd.command_detail, &q_data.cmd_data.send_ussd.command_detail, sizeof(struct tel_sat_cmd_detail_info));
3533         tr->terminal_rsp_data.send_ussd.device_id.src = DEVICE_ID_ME;
3534         tr->terminal_rsp_data.send_ussd.device_id.dest = q_data.cmd_data.send_ussd.device_id.src;
3535
3536         switch (resp) {
3537                 case RESULT_SUCCESS:
3538                         tr->terminal_rsp_data.send_ussd.result_type = RESULT_SUCCESS;
3539                         if (q_data.cmd_data.send_ussd.icon_id.is_exist)
3540                                 tr->terminal_rsp_data.send_ussd.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
3541
3542                         if(ussd_str_len > 0 && ussd_str){
3543                                 int local_index = 0, i = 0;
3544                                 guchar data;
3545                                 GVariantIter *iter = NULL;
3546                                 GVariant *intermediate = NULL;
3547                                 enum alphabet_format alpha_format;
3548
3549                                 intermediate = g_variant_get_variant(ussd_str);
3550                                 dbg("ussd string format(%s)", g_variant_get_type_string(intermediate));
3551
3552                                 g_variant_get(intermediate, "ay", &iter);
3553                                 while( g_variant_iter_loop (iter, "y", &data)){
3554                                         dbg("local_index(%d) data(%c)", local_index, data);
3555                                         tr->terminal_rsp_data.send_ussd.text.string[local_index] = data;
3556                                         local_index++;
3557                                 }
3558
3559                                 if(local_index >=1 )
3560                                         tr->terminal_rsp_data.send_ussd.text.string_length = local_index-1;
3561                                 tr->terminal_rsp_data.send_ussd.text.dcs.raw_dcs = q_data.cmd_data.send_ussd.ussd_string.dsc.raw_dcs;
3562                                 /*bits 2 & 3 indicate the character set being used */
3563                                 switch (tr->terminal_rsp_data.send_ussd.text.dcs.raw_dcs & 0x0C) {
3564                                         case 0x00:
3565                                         case 0x0C:
3566                                                 alpha_format = ALPHABET_FORMAT_SMS_DEFAULT;
3567                                                 break;
3568
3569                                         case 0x04:
3570                                                 alpha_format = ALPHABET_FORMAT_8BIT_DATA;
3571                                                 break;
3572
3573                                         case 0X08:
3574                                                 alpha_format = ALPHABET_FORMAT_UCS2;
3575                                                 break;
3576
3577                                         default:
3578                                                 alpha_format = ALPHABET_FORMAT_RESERVED;
3579                                                 break;
3580                                 }
3581                                 dbg("string :[%s] len:[%d] dcs:[%d] alpha_format:[%d]", tr->terminal_rsp_data.send_ussd.text.string, tr->terminal_rsp_data.send_ussd.text.string_length,
3582                                         tr->terminal_rsp_data.send_ussd.text.dcs.raw_dcs, alpha_format);
3583                                 g_variant_iter_free(iter);
3584                                 g_variant_unref(intermediate);
3585                                 switch(alpha_format){
3586                                         case ALPHABET_FORMAT_SMS_DEFAULT:
3587                                                 /* As per the test spec TS 151.010-04 raw dcs for SMS default is 0 */
3588                                                 tr->terminal_rsp_data.send_ussd.text.dcs.raw_dcs = ALPHABET_FORMAT_SMS_DEFAULT;
3589                                                 if (tr->terminal_rsp_data.send_ussd.text.string_length > 0){
3590                                                         int tmp_len;
3591                                                         char tmp_str[SAT_TEXT_STRING_LEN_MAX + 1];
3592                                                         char  *packed_data;
3593
3594                                                         dbg("UTF 8 to GSM SMS default");
3595                                                         tcore_util_convert_utf8_to_gsm((unsigned char*)tmp_str, &tmp_len,
3596                                                                 (unsigned char*)tr->terminal_rsp_data.send_ussd.text.string,
3597                                                                 tr->terminal_rsp_data.send_ussd.text.string_length);
3598                                                         packed_data = (char*) tcore_util_pack_gsm7bit((const unsigned char *)tmp_str, tmp_len);
3599                                                         memset(tr->terminal_rsp_data.send_ussd.text.string, 0x00,
3600                                                                 sizeof(tr->terminal_rsp_data.send_ussd.text.string));
3601                                                         if(packed_data){
3602                                                                 memcpy((void*)tr->terminal_rsp_data.send_ussd.text.string, packed_data, strlen(packed_data));
3603                                                                 tr->terminal_rsp_data.send_ussd.text.string_length = strlen(packed_data);
3604                                                                 g_free(packed_data);
3605                                                         }
3606                                                 }
3607                                                 dbg("final ussd len:%d", tr->terminal_rsp_data.send_ussd.text.string_length);
3608                                                 for(i = 0; i< tr->terminal_rsp_data.send_ussd.text.string_length; i++)
3609                                                         dbg("string :%c \n", tr->terminal_rsp_data.send_ussd.text.string[i]);
3610                                                 break;
3611                                         case ALPHABET_FORMAT_8BIT_DATA: {
3612                                                 gint output_data_len = 0;
3613                                                 gchar output_data[SAT_USSD_STRING_LEN_MAX];
3614                                                 dbg("UTF 8 to GSM 8 BIT DATA");
3615                                                 tcore_util_convert_utf8_to_gsm((unsigned char*)output_data,&output_data_len,
3616                                                         (unsigned char*)tr->terminal_rsp_data.send_ussd.text.string,
3617                                                         tr->terminal_rsp_data.send_ussd.text.string_length);
3618                                                 memset(tr->terminal_rsp_data.send_ussd.text.string, 0x00,
3619                                                         sizeof(tr->terminal_rsp_data.send_ussd.text.string));
3620                                                 if(output_data_len > 0){
3621                                                         memcpy((void*)tr->terminal_rsp_data.send_ussd.text.string, output_data, output_data_len);
3622                                                         tr->terminal_rsp_data.send_ussd.text.string_length = output_data_len;
3623                                                 }
3624                                                 dbg("final ussd len:%d", tr->terminal_rsp_data.send_ussd.text.string_length);
3625                                                 for(i = 0; i< tr->terminal_rsp_data.send_ussd.text.string_length; i++)
3626                                                         dbg("string :%c \n", tr->terminal_rsp_data.send_ussd.text.string[i]);
3627                                                 }
3628                                                 break;
3629                                         case ALPHABET_FORMAT_UCS2: {
3630                                                 char *tmp = NULL;
3631                                                 int str_len = 0;
3632                                                 dbg("UCS2 DATA");
3633                                                 tcore_util_convert_utf8_to_ucs2(&tmp,
3634                                                                 &str_len, (unsigned char*)tr->terminal_rsp_data.send_ussd.text.string,
3635                                                                 tr->terminal_rsp_data.send_ussd.text.string_length);
3636                                                 memset(tr->terminal_rsp_data.send_ussd.text.string, 0x00,
3637                                                         sizeof(tr->terminal_rsp_data.send_ussd.text.string));
3638                                                 memcpy(tr->terminal_rsp_data.send_ussd.text.string, tmp, str_len);
3639                                                 tr->terminal_rsp_data.send_ussd.text.string_length = str_len;
3640                                                 dbg("final ussd len:%d", tr->terminal_rsp_data.send_ussd.text.string_length);
3641                                                 for(i = 0; i< tr->terminal_rsp_data.send_ussd.text.string_length; i++)
3642                                                         dbg("string :%c \n", tr->terminal_rsp_data.send_ussd.text.string[i]);
3643                                                 g_free(tmp);
3644                                         }
3645                                                 break;
3646                                         default:
3647                                                 break;
3648                                 }
3649                         }
3650                         break;
3651
3652                 case RESULT_SS_RETURN_ERROR:
3653                 case RESULT_USSD_RETURN_ERROR:
3654                         tr->terminal_rsp_data.send_ussd.result_type = RESULT_USSD_RETURN_ERROR;
3655                         if(ss_cause == SATK_USSD_PROBLEM_UNKNOWN_ALPHABET)
3656                                 tr->terminal_rsp_data.send_ussd.ussd_problem = ss_cause;
3657
3658                         break;
3659
3660                 case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
3661                         tr->terminal_rsp_data.send_ussd.result_type = RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND;
3662                         tr->terminal_rsp_data.send_ussd.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3663                         break;
3664
3665                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
3666                         tr->terminal_rsp_data.send_ussd.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
3667                         tr->terminal_rsp_data.send_ussd.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3668                         break;
3669
3670                 default:
3671                         tr->terminal_rsp_data.send_ussd.result_type = RESULT_USSD_RETURN_ERROR;
3672                         tr->terminal_rsp_data.send_ussd.ussd_problem = SATK_USSD_PROBLEM_NO_SPECIFIC_CAUSE;
3673                         break;
3674         }
3675
3676         result = TRUE;
3677         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
3678         if(rv != TCORE_RETURN_SUCCESS){
3679                 dbg("fail to send terminal response");
3680                 result = FALSE;
3681         }
3682         g_free(tr);
3683
3684 #if defined(TIZEN_PLATFORM_USE_QCOM_QMI)
3685         if( q_data.cmd_data.send_ussd.alpha_id.alpha_data_len && q_data.cmd_data.send_ussd.alpha_id.is_exist ) {
3686                 char *path;
3687                 const gchar *cp_name;
3688                 TelephonySAT *sat;
3689                 TelephonyObjectSkeleton *object;
3690
3691                 dbg("AlphaID is present, terminate SAT-UI.");
3692                 //emit session end signal
3693                 cp_name = tcore_server_get_cp_name_by_plugin(plg);
3694                 if (cp_name == NULL) {
3695                         err("CP name is NULL");
3696                         goto Exit;
3697                 }
3698
3699                 dbg("CP Name: [%s]", cp_name);
3700                 path = g_strdup_printf("%s/%s", MY_DBUS_PATH, cp_name);
3701
3702                 /* Look-up Hash table for Object */
3703                 object = g_hash_table_lookup(ctx->objects, path);
3704                 dbg("Path: [%s] Interface object: [%p]", path, object);
3705                 g_free(path);
3706                 if (object == NULL) {
3707                         err("Object is NOT defined!!!");
3708                         goto Exit;
3709                 }
3710
3711                 sat = telephony_object_peek_sat(TELEPHONY_OBJECT(object));
3712                 telephony_sat_emit_end_proactive_session(sat, SAT_PROATV_CMD_TYPE_END_PROACTIVE_SESSION);
3713         }
3714
3715 Exit:
3716 #endif
3717         return result;
3718 }
3719
3720 static gboolean _sat_manager_handle_setup_call_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
3721 {
3722         TReturn rv = TCORE_RETURN_FAILURE;
3723         gboolean result = FALSE;
3724
3725         gint resp, me_problem, cc_problem, call_cause;
3726         struct treq_sat_terminal_rsp_data *tr;
3727         struct sat_manager_queue_data q_data;
3728
3729         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
3730
3731         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
3732                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
3733                 return result;
3734         }
3735
3736         if(!exec_result){
3737                 dbg("[SAT] setup call data is null");
3738                 return result;
3739         }
3740
3741         if (!plg){
3742                 dbg("there is no valid plugin at this point");
3743                 return result;
3744         }
3745
3746         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
3747         g_variant_get(exec_result, "(iiii)",&resp, &me_problem, &cc_problem, &call_cause);
3748
3749         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
3750         if (!tr)
3751                 return result;
3752
3753         tr->cmd_number = q_data.cmd_data.setup_call.command_detail.cmd_num;
3754         tr->cmd_type = q_data.cmd_data.setup_call.command_detail.cmd_type;
3755         memcpy((void*)&tr->terminal_rsp_data.setup_call.command_detail, &q_data.cmd_data.setup_call.command_detail, sizeof(struct tel_sat_cmd_detail_info));
3756         tr->terminal_rsp_data.setup_call.device_id.src = DEVICE_ID_ME;
3757         tr->terminal_rsp_data.setup_call.device_id.dest = q_data.cmd_data.setup_call.device_id.src;
3758
3759         switch (resp) {
3760                 case RESULT_SUCCESS:
3761                         tr->terminal_rsp_data.setup_call.result_type = RESULT_SUCCESS;
3762                         if (q_data.cmd_data.setup_call.call_setup_icon_id.is_exist || q_data.cmd_data.setup_call.user_confirm_icon_id.is_exist)
3763                                 tr->terminal_rsp_data.setup_call.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
3764                         tr->terminal_rsp_data.setup_call.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3765                         tr->terminal_rsp_data.setup_call.cc_problem_type = CC_PROBLEM_NO_SPECIFIC_CAUSE;
3766                         break;
3767
3768                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
3769                         tr->terminal_rsp_data.setup_call.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
3770                         tr->terminal_rsp_data.setup_call.me_problem_type = me_problem;
3771                         break;
3772
3773                 case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:{
3774                         tr->terminal_rsp_data.setup_call.result_type = RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND;
3775                         switch(call_cause){
3776                                 case CALL_ERROR_BUSY:
3777                                         tr->terminal_rsp_data.setup_call.network_problem_type = NETWORK_PROBLEM_USER_BUSY;
3778                                 break;
3779                                 default :
3780                                         tr->terminal_rsp_data.setup_call.network_problem_type = NETWORK_PROBLEM_NO_SPECIFIC_CAUSE;
3781                                 break;
3782                         }
3783                 }break;
3784
3785                 case RESULT_USER_CLEAR_DOWN_CALL_BEFORE_CONN:
3786                         tr->terminal_rsp_data.setup_call.result_type = RESULT_USER_CLEAR_DOWN_CALL_BEFORE_CONN;
3787                         tr->terminal_rsp_data.setup_call.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3788                         tr->terminal_rsp_data.setup_call.cc_problem_type = CC_PROBLEM_NO_SPECIFIC_CAUSE;
3789                         break;
3790
3791                 case RESULT_BEYOND_ME_CAPABILITIES:
3792                         tr->terminal_rsp_data.setup_call.result_type = RESULT_BEYOND_ME_CAPABILITIES;
3793                         tr->terminal_rsp_data.setup_call.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3794                         tr->terminal_rsp_data.setup_call.cc_problem_type = CC_PROBLEM_NO_SPECIFIC_CAUSE;
3795                         break;
3796
3797                 case RESULT_INTRCTN_WITH_CC_OR_SMS_CTRL_PRMNT_PRBLM:
3798                         tr->terminal_rsp_data.setup_call.result_type = RESULT_INTRCTN_WITH_CC_OR_SMS_CTRL_PRMNT_PRBLM;
3799                         tr->terminal_rsp_data.setup_call.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3800                         tr->terminal_rsp_data.setup_call.cc_problem_type = cc_problem;
3801                         break;
3802
3803
3804                 default:
3805                         break;
3806         }
3807
3808         //TODO Other infomation set - not supported
3809         tr->terminal_rsp_data.setup_call.other_info = FALSE;
3810
3811         result = TRUE;
3812         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
3813         if(rv != TCORE_RETURN_SUCCESS){
3814                 dbg("fail to send terminal response");
3815                 result = FALSE;
3816         }
3817
3818         g_free(tr);
3819         return result;
3820 }
3821
3822 static gboolean _sat_manager_handle_setup_idle_mode_text_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
3823 {
3824         TReturn rv = TCORE_RETURN_FAILURE;
3825         gboolean result = FALSE;
3826
3827         gint resp;
3828         struct treq_sat_terminal_rsp_data tr;
3829         struct sat_manager_queue_data q_data;
3830
3831         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
3832         memset(&tr, 0, sizeof(struct treq_sat_terminal_rsp_data));
3833
3834         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
3835                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
3836                 return result;
3837         }
3838
3839         if(!exec_result){
3840                 dbg("[SAT] send ss data is null");
3841                 return result;
3842         }
3843
3844         if (!plg){
3845                 dbg("there is no valid plugin at this point");
3846                 return result;
3847         }
3848
3849         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
3850         g_variant_get(exec_result, "(i)",&resp);
3851
3852         tr.cmd_number = q_data.cmd_data.idle_mode.command_detail.cmd_num;
3853         tr.cmd_type = q_data.cmd_data.idle_mode.command_detail.cmd_type;
3854         memcpy((void*)&tr.terminal_rsp_data.setup_idle_mode_text.command_detail, &q_data.cmd_data.idle_mode.command_detail, sizeof(struct tel_sat_cmd_detail_info));
3855         tr.terminal_rsp_data.setup_idle_mode_text.device_id.src = q_data.cmd_data.idle_mode.device_id.dest;
3856         tr.terminal_rsp_data.setup_idle_mode_text.device_id.dest = q_data.cmd_data.idle_mode.device_id.src;
3857
3858         switch (resp) {
3859                 case RESULT_SUCCESS:
3860                         tr.terminal_rsp_data.setup_idle_mode_text.result_type = RESULT_SUCCESS;
3861                         if (q_data.cmd_data.idle_mode.icon_id.is_exist)
3862                                 tr.terminal_rsp_data.setup_idle_mode_text.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
3863
3864                         break;
3865                 default:
3866                         tr.terminal_rsp_data.setup_idle_mode_text.result_type = resp;
3867                         break;
3868         }
3869
3870         result = TRUE;
3871         rv = sat_manager_send_terminal_response(ctx->comm, plg, &tr);
3872         if(rv != TCORE_RETURN_SUCCESS){
3873                 dbg("fail to send terminal response");
3874                 result = FALSE;
3875         }
3876
3877         return result;
3878 }
3879
3880 static gboolean sat_manager_handle_open_channel_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
3881 {
3882         TReturn rv = TCORE_RETURN_FAILURE;
3883         gboolean result = FALSE;
3884
3885         gint resp, me_problem, bip_problem;
3886         gint bearer_type, channel_id, channel_status, channel_status_info, buffer_size;
3887         gboolean other_info;
3888         GVariant *desc_tmp, *bearer_desc;
3889
3890         struct treq_sat_terminal_rsp_data *tr;
3891         struct sat_manager_queue_data q_data;
3892
3893         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
3894
3895         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
3896                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
3897                 return result;
3898         }
3899
3900         if(!exec_result){
3901                 dbg("[SAT] open channel data is null");
3902                 return result;
3903         }
3904
3905         if (!plg){
3906                 dbg("there is no valid plugin at this point");
3907                 return result;
3908         }
3909
3910         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
3911         g_variant_get(exec_result, "(iiiiiiiibv)",&resp, &me_problem, &bip_problem,
3912                         &bearer_type, &channel_id, &channel_status, &channel_status_info, &buffer_size,
3913                         &other_info, &desc_tmp);
3914
3915         bearer_desc = g_variant_get_variant(desc_tmp);
3916
3917         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
3918         if (!tr)
3919                 return result;
3920         tr->cmd_number = q_data.cmd_data.open_channel.command_detail.cmd_num;
3921         tr->cmd_type = q_data.cmd_data.open_channel.command_detail.cmd_type;
3922         memcpy((void*)&tr->terminal_rsp_data.open_channel.command_detail, &q_data.cmd_data.open_channel.command_detail, sizeof(struct tel_sat_cmd_detail_info));
3923
3924         tr->terminal_rsp_data.open_channel.device_id.src = q_data.cmd_data.open_channel.device_id.dest;
3925         tr->terminal_rsp_data.open_channel.device_id.dest = q_data.cmd_data.open_channel.device_id.src;
3926
3927         tr->terminal_rsp_data.open_channel.result_type = resp;
3928         switch (resp) {
3929                 case RESULT_SUCCESS:
3930                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
3931                 case RESULT_SUCCESS_WITH_MISSING_INFO:
3932                         //channel status
3933                         break;
3934
3935                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
3936                 case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
3937                         tr->terminal_rsp_data.open_channel.me_problem_type = me_problem;
3938                         break;
3939
3940                 case RESULT_BEARER_INDEPENDENT_PROTOCOL_ERROR:
3941                         tr->terminal_rsp_data.open_channel.bip_problem_type = bip_problem;
3942                         break;
3943
3944                 default:
3945                         break;
3946         }
3947
3948         tr->terminal_rsp_data.open_channel.channel_status.channel_id = channel_id;
3949         tr->terminal_rsp_data.open_channel.channel_status.status = channel_status;
3950         tr->terminal_rsp_data.open_channel.channel_status.status_info = channel_status_info;
3951
3952         dbg("check channel id(%d) channel status(%d) channel info(%d)", channel_id, channel_status, channel_status_info);
3953
3954         //memcpy(tr->terminal_rsp_data.open_channel.buffer_size.size, &buffer_size, sizeof(unsigned char)*2);
3955         tr->terminal_rsp_data.open_channel.buffer_size.size[0] = buffer_size >> 8;
3956         tr->terminal_rsp_data.open_channel.buffer_size.size[1] = buffer_size & 0xFF;
3957         dbg("check buffer size[0](0x%x) size[1](0x%x)", tr->terminal_rsp_data.open_channel.buffer_size.size[0], tr->terminal_rsp_data.open_channel.buffer_size.size[1]);
3958
3959         tr->terminal_rsp_data.open_channel.bearer_desc.bearer_type = bearer_type;
3960         switch(bearer_type){
3961                 case BEARER_CSD:{
3962                         gint data_rate, service_type, conn_element_type;
3963
3964                         dbg("bearer_desc cs bearer type_format(%s)", g_variant_get_type_string(bearer_desc));
3965                         g_variant_get(bearer_desc, "(iii)",&data_rate, &service_type, &conn_element_type);
3966                         dbg("check cs bearer data_rade(%d), service_type(%d), conn_element_type(%d)", data_rate, service_type, conn_element_type);
3967
3968                         tr->terminal_rsp_data.open_channel.bearer_desc.bearer_parameter.cs_bearer_param.data_rate = data_rate;
3969                         tr->terminal_rsp_data.open_channel.bearer_desc.bearer_parameter.cs_bearer_param.service_type = service_type;
3970                         tr->terminal_rsp_data.open_channel.bearer_desc.bearer_parameter.cs_bearer_param.connection_element_type = conn_element_type;
3971                 }break;
3972                 case BEARER_GPRS:{
3973                         gint precedence_class, delay_class, reliability_class;
3974                         gint peak_class, mean_class, pdp_type;
3975
3976                         dbg("bearer_desc ps bearer type_format(%s)", g_variant_get_type_string(bearer_desc));
3977                         g_variant_get(bearer_desc, "(iiiiii)",&precedence_class, &delay_class, &reliability_class,
3978                                         &peak_class, &mean_class, &pdp_type);
3979                         dbg("check ps bearer precedence class(%d), delay class(%d), reliability class(%d) peak class(%d) mean class(%d) pdp_type(%d)",
3980                                         precedence_class, delay_class, reliability_class, peak_class, mean_class, pdp_type);
3981
3982                         tr->terminal_rsp_data.open_channel.bearer_desc.bearer_parameter.ps_bearer_param.precedence_class = precedence_class;
3983                         tr->terminal_rsp_data.open_channel.bearer_desc.bearer_parameter.ps_bearer_param.delay_class = delay_class;
3984                         tr->terminal_rsp_data.open_channel.bearer_desc.bearer_parameter.ps_bearer_param.reliability_class = reliability_class;
3985                         tr->terminal_rsp_data.open_channel.bearer_desc.bearer_parameter.ps_bearer_param.peak_throughput_class = peak_class;
3986                         tr->terminal_rsp_data.open_channel.bearer_desc.bearer_parameter.ps_bearer_param.mean_throughput_class = mean_class;
3987                         tr->terminal_rsp_data.open_channel.bearer_desc.bearer_parameter.ps_bearer_param.pdp_type = pdp_type;
3988                 }break;
3989                 case BEARER_LOCAL_LINK_TECHNOLOGY_INDEPENDENT:{
3990                         gint service_type;
3991                         gchar *service_record = NULL;
3992
3993                         dbg("bearer_desc link local type_format(%s)", g_variant_get_type_string(bearer_desc));
3994                         g_variant_get(bearer_desc, "(is)",&service_type, &service_record);
3995                         dbg("check link local service_type(%d), service_record(%d)", service_type, service_record);
3996
3997                         tr->terminal_rsp_data.open_channel.bearer_desc.bearer_parameter.local_link_bearer_param.service_type = service_type;
3998
3999                         if(service_record) {
4000                                 memcpy(tr->terminal_rsp_data.open_channel.bearer_desc.bearer_parameter.local_link_bearer_param.service_record, service_record, strlen(service_record));
4001                                 g_free(service_record);
4002                         }
4003
4004                 }break;
4005                 default:
4006                 break;
4007         }
4008
4009         result = TRUE;
4010         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
4011         if(rv != TCORE_RETURN_SUCCESS){
4012                 dbg("fail to send terminal response");
4013                 result = FALSE;
4014         }
4015
4016         g_free(tr);
4017         return result;
4018 }
4019
4020 static gboolean sat_manager_handle_close_channel_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
4021 {
4022         TReturn rv = TCORE_RETURN_FAILURE;
4023         gboolean result = FALSE;
4024
4025         gint resp, me_problem, bip_problem;
4026
4027         struct treq_sat_terminal_rsp_data *tr;
4028         struct sat_manager_queue_data q_data;
4029
4030         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
4031
4032         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
4033                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
4034                 return result;
4035         }
4036
4037         if(!exec_result){
4038                 dbg("[SAT] close channel data is null");
4039                 return result;
4040         }
4041
4042         if (!plg){
4043                 dbg("there is no valid plugin at this point");
4044                 return result;
4045         }
4046
4047         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
4048         g_variant_get(exec_result, "(iii)",&resp, &me_problem, &bip_problem);
4049
4050         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
4051         if (!tr)
4052                 return result;
4053         tr->cmd_number = q_data.cmd_data.close_channel.command_detail.cmd_num;
4054         tr->cmd_type = q_data.cmd_data.close_channel.command_detail.cmd_type;
4055         memcpy((void*)&tr->terminal_rsp_data.close_channel.command_detail, &q_data.cmd_data.close_channel.command_detail, sizeof(struct tel_sat_cmd_detail_info));
4056
4057         tr->terminal_rsp_data.close_channel.device_id.src = DEVICE_ID_ME;
4058         tr->terminal_rsp_data.close_channel.device_id.dest = q_data.cmd_data.close_channel.device_id.src;
4059
4060         tr->terminal_rsp_data.close_channel.result_type = resp;
4061         switch (resp) {
4062                 case RESULT_SUCCESS:
4063                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
4064                 case RESULT_SUCCESS_WITH_MISSING_INFO:
4065                         //channel status
4066                         break;
4067
4068                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
4069                 case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
4070                         tr->terminal_rsp_data.close_channel.me_problem_type = me_problem;
4071                         break;
4072
4073                 case RESULT_BEARER_INDEPENDENT_PROTOCOL_ERROR:
4074                         tr->terminal_rsp_data.close_channel.bip_problem_type = bip_problem;
4075                         break;
4076
4077                 default:
4078                         break;
4079         }
4080
4081         result = TRUE;
4082         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
4083         if(rv != TCORE_RETURN_SUCCESS){
4084                 dbg("fail to send terminal response");
4085                 result = FALSE;
4086         }
4087
4088         g_free(tr);
4089         return result;
4090 }
4091
4092 static gboolean sat_manager_handle_receive_data_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
4093 {
4094         TReturn rv = TCORE_RETURN_FAILURE;
4095         gboolean result = FALSE;
4096
4097         gint resp, me_problem, bip_problem;
4098         gint data_str_len, data_len;
4099         gboolean other_info;
4100         GVariant *received_data;
4101
4102         struct treq_sat_terminal_rsp_data *tr;
4103         struct sat_manager_queue_data q_data;
4104
4105         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
4106
4107         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
4108                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
4109                 return result;
4110         }
4111
4112         if(!exec_result){
4113                 dbg("[SAT] receive data data is null");
4114                 return result;
4115         }
4116
4117         if (!plg){
4118                 dbg("there is no valid plugin at this point");
4119                 return result;
4120         }
4121
4122         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
4123         g_variant_get(exec_result, "(iiiiibv)",&resp, &me_problem, &bip_problem, &data_str_len, &data_len, &other_info, &received_data);
4124
4125         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
4126         if (!tr)
4127                 return result;
4128         tr->cmd_number = q_data.cmd_data.receive_data.command_detail.cmd_num;
4129         tr->cmd_type = q_data.cmd_data.receive_data.command_detail.cmd_type;
4130         memcpy((void*)&tr->terminal_rsp_data.receive_data.command_detail, &q_data.cmd_data.receive_data.command_detail, sizeof(struct tel_sat_cmd_detail_info));
4131
4132         tr->terminal_rsp_data.receive_data.device_id.src = DEVICE_ID_ME;
4133         tr->terminal_rsp_data.receive_data.device_id.dest = q_data.cmd_data.receive_data.device_id.src;
4134
4135         tr->terminal_rsp_data.receive_data.result_type = resp;
4136         switch (resp) {
4137                 case RESULT_SUCCESS:
4138                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
4139                 case RESULT_SUCCESS_WITH_MISSING_INFO:
4140                         //channel status
4141                         break;
4142
4143                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
4144                 case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
4145                         tr->terminal_rsp_data.receive_data.me_problem_type = me_problem;
4146                         break;
4147
4148                 case RESULT_BEARER_INDEPENDENT_PROTOCOL_ERROR:
4149                         tr->terminal_rsp_data.receive_data.bip_problem_type = bip_problem;
4150                         break;
4151
4152                 default:
4153                         break;
4154         }
4155
4156         tr->terminal_rsp_data.receive_data.channel_data_len.data_len = data_len;
4157         tr->terminal_rsp_data.receive_data.channel_data.data_string_len = data_str_len;
4158
4159         if(received_data){
4160                 int local_index = 0;
4161                 guchar data;
4162                 GVariantIter *iter = NULL;
4163
4164                 dbg("additional data exist type_format(%s)", g_variant_get_type_string(received_data));
4165
4166                 g_variant_get(received_data, "ay", &iter);
4167                 while( g_variant_iter_loop (iter, "y", &data)){
4168                         //dbg("index(%d) data(%d)", index, data);
4169                         tr->terminal_rsp_data.receive_data.channel_data.data_string[local_index] = data;
4170                         local_index++;
4171                 }
4172                 g_variant_iter_free(iter);
4173
4174                 dbg("the last index data(%d), data_total_len(%d)", local_index, data_str_len);
4175         }
4176
4177         result = TRUE;
4178         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
4179         if(rv != TCORE_RETURN_SUCCESS){
4180                 dbg("fail to send terminal response");
4181                 result = FALSE;
4182         }
4183
4184         g_free(tr);
4185         return result;
4186 }
4187
4188 static gboolean sat_manager_handle_send_data_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
4189 {
4190         TReturn rv = TCORE_RETURN_FAILURE;
4191         gboolean result = FALSE;
4192
4193         gint resp, me_problem, bip_problem;
4194         gint data_len;
4195
4196         struct treq_sat_terminal_rsp_data *tr;
4197         struct sat_manager_queue_data q_data;
4198
4199         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
4200
4201         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
4202                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
4203                 return result;
4204         }
4205
4206         if(!exec_result){
4207                 dbg("[SAT] send data data is null");
4208                 return result;
4209         }
4210
4211         if (!plg){
4212                 dbg("there is no valid plugin at this point");
4213                 return result;
4214         }
4215
4216         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
4217         g_variant_get(exec_result, "(iiii)",&resp, &me_problem, &bip_problem, &data_len);
4218
4219         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
4220         if (!tr)
4221                 return result;
4222         tr->cmd_number = q_data.cmd_data.send_data.command_detail.cmd_num;
4223         tr->cmd_type = q_data.cmd_data.send_data.command_detail.cmd_type;
4224         memcpy((void*)&tr->terminal_rsp_data.send_data.command_detail, &q_data.cmd_data.send_data.command_detail, sizeof(struct tel_sat_cmd_detail_info));
4225
4226         tr->terminal_rsp_data.send_data.device_id.src = DEVICE_ID_ME;
4227         tr->terminal_rsp_data.send_data.device_id.dest = q_data.cmd_data.send_data.device_id.src;
4228
4229         tr->terminal_rsp_data.send_data.result_type = resp;
4230         switch (resp) {
4231                 case RESULT_SUCCESS:
4232                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
4233                 case RESULT_SUCCESS_WITH_MISSING_INFO:
4234                         //channel status
4235                         break;
4236
4237                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
4238                 case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
4239                         tr->terminal_rsp_data.send_data.me_problem_type = me_problem;
4240                         break;
4241
4242                 case RESULT_BEARER_INDEPENDENT_PROTOCOL_ERROR:
4243                         tr->terminal_rsp_data.send_data.bip_problem_type = bip_problem;
4244                         break;
4245
4246                 default:
4247                         break;
4248         }
4249
4250         tr->terminal_rsp_data.send_data.channel_data_len.data_len = data_len;
4251
4252         result = TRUE;
4253         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
4254         if(rv != TCORE_RETURN_SUCCESS){
4255                 dbg("fail to send terminal response");
4256                 result = FALSE;
4257         }
4258
4259         g_free(tr);
4260         return result;
4261 }
4262
4263 static gboolean sat_manager_handle_get_channel_status_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
4264 {
4265         TReturn rv = TCORE_RETURN_FAILURE;
4266         gboolean result = FALSE;
4267
4268         gint resp, me_problem, bip_problem;
4269         gint channel_id, channel_status, channel_status_info;
4270
4271         struct treq_sat_terminal_rsp_data *tr;
4272         struct sat_manager_queue_data q_data;
4273
4274         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
4275
4276         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
4277                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
4278                 return result;
4279         }
4280
4281         if(!exec_result){
4282                 dbg("[SAT] get channel status data is null");
4283                 return result;
4284         }
4285
4286         if (!plg){
4287                 dbg("there is no valid plugin at this point");
4288                 return result;
4289         }
4290
4291         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
4292         g_variant_get(exec_result, "(iiiiii)",&resp, &me_problem, &bip_problem,
4293                         &channel_id, &channel_status, &channel_status_info);
4294
4295         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
4296         if (!tr)
4297                 return result;
4298         tr->cmd_number = q_data.cmd_data.get_channel_status.command_detail.cmd_num;
4299         tr->cmd_type = q_data.cmd_data.get_channel_status.command_detail.cmd_type;
4300         memcpy((void*)&tr->terminal_rsp_data.get_channel_status.command_detail, &q_data.cmd_data.get_channel_status.command_detail, sizeof(struct tel_sat_cmd_detail_info));
4301
4302         tr->terminal_rsp_data.get_channel_status.device_id.src = q_data.cmd_data.get_channel_status.device_id.dest;
4303         tr->terminal_rsp_data.get_channel_status.device_id.dest = q_data.cmd_data.get_channel_status.device_id.src;
4304
4305         tr->terminal_rsp_data.get_channel_status.result_type = resp;
4306         switch (resp) {
4307                 case RESULT_SUCCESS:
4308                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
4309                 case RESULT_SUCCESS_WITH_MISSING_INFO:
4310                         //channel status
4311                         break;
4312
4313                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
4314                 case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
4315                         tr->terminal_rsp_data.get_channel_status.me_problem_type = me_problem;
4316                         break;
4317
4318                 case RESULT_BEARER_INDEPENDENT_PROTOCOL_ERROR:
4319                         tr->terminal_rsp_data.get_channel_status.bip_problem_type = bip_problem;
4320                         break;
4321
4322                 default:
4323                         break;
4324         }
4325
4326         tr->terminal_rsp_data.get_channel_status.channel_status.channel_id = channel_id;
4327         tr->terminal_rsp_data.get_channel_status.channel_status.status = channel_status;
4328         tr->terminal_rsp_data.get_channel_status.channel_status.status_info = channel_status_info;
4329
4330         result = TRUE;
4331         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
4332         if(rv != TCORE_RETURN_SUCCESS){
4333                 dbg("fail to send terminal response");
4334                 result = FALSE;
4335         }
4336
4337         g_free(tr);
4338         return result;
4339 }
4340
4341 static gboolean sat_manager_handle_send_dtmf_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
4342 {
4343         TReturn rv = TCORE_RETURN_FAILURE;
4344         gboolean result = FALSE;
4345
4346         gint resp;
4347         struct treq_sat_terminal_rsp_data *tr;
4348         struct sat_manager_queue_data q_data;
4349
4350         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
4351         if (!tr)
4352                 return result;
4353         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
4354
4355         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
4356                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
4357                 g_free(tr);
4358                 return result;
4359         }
4360
4361         if(!exec_result){
4362                 dbg("[SAT] get channel status data is null");
4363                 g_free(tr);
4364                 return result;
4365         }
4366
4367         if (!plg){
4368                 dbg("there is no valid plugin at this point");
4369                 g_free(tr);
4370                 return result;
4371         }
4372
4373         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
4374         g_variant_get(exec_result, "(i)",&resp);
4375
4376         tr->cmd_number = q_data.cmd_data.send_dtmf.command_detail.cmd_num;
4377         tr->cmd_type = q_data.cmd_data.send_dtmf.command_detail.cmd_type;
4378         memcpy((void*)&tr->terminal_rsp_data.send_dtmf.command_detail, &q_data.cmd_data.send_dtmf.command_detail, sizeof(struct tel_sat_cmd_detail_info));
4379
4380         tr->terminal_rsp_data.send_dtmf.device_id.src = DEVICE_ID_ME;
4381         tr->terminal_rsp_data.send_dtmf.device_id.dest = q_data.cmd_data.send_dtmf.device_id.src;
4382
4383         tr->terminal_rsp_data.send_dtmf.result_type = resp;
4384         switch (resp) {
4385                 case RESULT_SUCCESS:
4386                         if (q_data.cmd_data.send_dtmf.icon_id.is_exist)
4387                                 tr->terminal_rsp_data.send_dtmf.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
4388                         break;
4389
4390                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
4391                         tr->terminal_rsp_data.send_dtmf.me_problem_type = ME_PROBLEM_NOT_IN_SPEECH_CALL;
4392                         break;
4393
4394                 default:
4395                         tr->terminal_rsp_data.send_dtmf.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
4396                         tr->terminal_rsp_data.send_dtmf.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
4397                         break;
4398         }
4399
4400         result = TRUE;
4401         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
4402         if(rv != TCORE_RETURN_SUCCESS){
4403                 dbg("fail to send terminal response");
4404                 result = FALSE;
4405         }
4406
4407         g_free(tr);
4408         return result;
4409 }
4410
4411 static gboolean sat_manager_handle_launch_browser_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
4412 {
4413         TReturn rv = TCORE_RETURN_FAILURE;
4414         gboolean result = FALSE;
4415
4416         gint resp, browser_problem;
4417         struct treq_sat_terminal_rsp_data *tr;
4418         struct sat_manager_queue_data q_data;
4419
4420         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
4421
4422         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
4423                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
4424                 return result;
4425         }
4426
4427         if(!exec_result){
4428                 dbg("[SAT] get channel status data is null");
4429                 return result;
4430         }
4431
4432         if (!plg){
4433                 dbg("there is no valid plugin at this point");
4434                 return result;
4435         }
4436
4437         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
4438         g_variant_get(exec_result, "(ii)",&resp,&browser_problem);
4439
4440         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
4441         if (!tr)
4442                 return result;
4443         tr->cmd_number = q_data.cmd_data.launch_browser.command_detail.cmd_num;
4444         tr->cmd_type = q_data.cmd_data.launch_browser.command_detail.cmd_type;
4445         memcpy((void*)&tr->terminal_rsp_data.launch_browser.command_detail, &q_data.cmd_data.launch_browser.command_detail, sizeof(struct tel_sat_cmd_detail_info));
4446
4447         tr->terminal_rsp_data.launch_browser.device_id.src = q_data.cmd_data.launch_browser.device_id.dest;
4448         tr->terminal_rsp_data.launch_browser.device_id.dest = q_data.cmd_data.launch_browser.device_id.src;
4449
4450         tr->terminal_rsp_data.launch_browser.result_type = resp;
4451         switch (resp) {
4452                 case RESULT_SUCCESS:
4453                         if (q_data.cmd_data.launch_browser.user_confirm_icon_id.is_exist)
4454                                 tr->terminal_rsp_data.launch_browser.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
4455
4456                         tr->terminal_rsp_data.launch_browser.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
4457                         tr->terminal_rsp_data.launch_browser.browser_problem_type = BROWSER_PROBLEM_NO_SPECIFIC_CAUSE;
4458                         break;
4459                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
4460                         tr->terminal_rsp_data.launch_browser.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
4461                         tr->terminal_rsp_data.launch_browser.browser_problem_type = BROWSER_PROBLEM_NO_SPECIFIC_CAUSE;
4462                         break;
4463
4464                 case RESULT_LAUNCH_BROWSER_GENERIC_ERROR_CODE:
4465                         tr->terminal_rsp_data.launch_browser.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
4466                         tr->terminal_rsp_data.launch_browser.browser_problem_type = browser_problem;
4467                         break;
4468                 default:
4469                         tr->terminal_rsp_data.launch_browser.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
4470                         tr->terminal_rsp_data.launch_browser.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
4471                         tr->terminal_rsp_data.launch_browser.browser_problem_type = BROWSER_PROBLEM_NO_SPECIFIC_CAUSE;
4472                         break;
4473         }
4474
4475         result = TRUE;
4476         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
4477         if(rv != TCORE_RETURN_SUCCESS){
4478                 dbg("fail to send terminal response");
4479                 result = FALSE;
4480         }
4481
4482         g_free(tr);
4483         return result;
4484 }
4485
4486 gboolean sat_manager_handle_app_exec_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gint command_type, GVariant *exec_result)
4487 {
4488         gboolean result = FALSE;
4489         GVariant *resp = NULL;
4490         dbg("[SAT] app exec result command id(%d) command type(%d)", command_id, command_type);
4491
4492         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
4493         g_variant_get(exec_result, "v", &resp);
4494
4495         switch (command_type) {
4496                 case SAT_PROATV_CMD_SETUP_MENU:
4497                         result = _sat_manager_handle_setup_menu_result(ctx, plg, command_id, resp);
4498                         break;
4499
4500                 case SAT_PROATV_CMD_DISPLAY_TEXT:
4501                         result = _sat_manager_handle_display_text_result(ctx, plg, command_id, resp);
4502                         break;
4503
4504                 case SAT_PROATV_CMD_PLAY_TONE:
4505                         result = _sat_manager_handle_play_tone_result(ctx, plg, command_id, resp);
4506                         break;
4507
4508                 case SAT_PROATV_CMD_SEND_SMS:
4509                         result = _sat_manager_handle_send_sms_result(ctx, plg, command_id, resp);
4510                         break;
4511
4512                 case SAT_PROATV_CMD_SEND_SS:
4513                         result = _sat_manager_handle_send_ss_result(ctx, plg, command_id, resp);
4514                         break;
4515
4516                 case SAT_PROATV_CMD_SEND_USSD:
4517                         result = _sat_manager_handle_send_ussd_result(ctx, plg, command_id, resp);
4518                         break;
4519
4520                 case SAT_PROATV_CMD_SETUP_CALL:
4521                         result = _sat_manager_handle_setup_call_result(ctx, plg, command_id, resp);
4522                         break;
4523
4524                 case SAT_PROATV_CMD_SETUP_IDLE_MODE_TEXT:
4525                         result = _sat_manager_handle_setup_idle_mode_text_result(ctx, plg, command_id, resp);
4526                         break;
4527
4528                 case SAT_PROATV_CMD_OPEN_CHANNEL:
4529                         result = sat_manager_handle_open_channel_result(ctx, plg, command_id, resp);
4530                         break;
4531
4532                 case SAT_PROATV_CMD_CLOSE_CHANNEL:
4533                         result = sat_manager_handle_close_channel_result(ctx, plg, command_id, resp);
4534                         break;
4535
4536                 case SAT_PROATV_CMD_RECEIVE_DATA:
4537                         result = sat_manager_handle_receive_data_result(ctx, plg, command_id, resp);
4538                         break;
4539
4540                 case SAT_PROATV_CMD_SEND_DATA:
4541                         result = sat_manager_handle_send_data_result(ctx, plg, command_id, resp);
4542                         break;
4543
4544                 case SAT_PROATV_CMD_GET_CHANNEL_STATUS:
4545                         result = sat_manager_handle_get_channel_status_result(ctx, plg, command_id, resp);
4546                         break;
4547
4548                 case SAT_PROATV_CMD_SEND_DTMF:
4549                         result = sat_manager_handle_send_dtmf_result(ctx, plg, command_id, resp);
4550                         break;
4551
4552                 case SAT_PROATV_CMD_LAUNCH_BROWSER:
4553                         result = sat_manager_handle_launch_browser_result(ctx, plg, command_id, resp);
4554                         break;
4555
4556                 default:
4557                         dbg("[SAT] invalid command type(%d)", command_type);
4558                         break;
4559         }
4560
4561         return result;
4562 }
4563
4564 static gboolean _sat_manager_handle_menu_select_confirm(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gint confirm_type, GVariant *addtional_data)
4565 {
4566         TReturn rv = TCORE_RETURN_FAILURE;
4567         gboolean result = FALSE;
4568
4569         gint item_id=0;
4570         struct treq_sat_terminal_rsp_data *tr;
4571         struct sat_manager_queue_data q_data;
4572
4573         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
4574
4575         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
4576                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
4577                 return result;
4578         }
4579
4580         if (!plg){
4581                 dbg("there is no valid plugin at this point");
4582                 return result;
4583         }
4584
4585         if(addtional_data){
4586                 int local_index = 0;
4587                 guchar data;
4588                 GVariantIter *iter = NULL;
4589                 GVariant *inner_gv = NULL;
4590
4591                 inner_gv = g_variant_get_variant(addtional_data);
4592                 dbg("additional data exist type_format(%s)", g_variant_get_type_string(inner_gv));
4593
4594                 g_variant_get(inner_gv, "ay", &iter);
4595                 while( g_variant_iter_loop (iter, "y", &data)){
4596                         dbg("index(%d) data(%d)", local_index, data);
4597                         item_id = data;
4598                         local_index++;
4599                 }
4600                 g_variant_iter_free(iter);
4601                 g_variant_unref(inner_gv);
4602         }
4603
4604         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
4605         if (!tr)
4606                 return result;
4607         tr->cmd_number = q_data.cmd_data.selectItemInd.command_detail.cmd_num;
4608         tr->cmd_type = q_data.cmd_data.selectItemInd.command_detail.cmd_type;
4609         memcpy((void*)&tr->terminal_rsp_data.select_item.command_detail, &q_data.cmd_data.selectItemInd.command_detail, sizeof(struct tel_sat_cmd_detail_info));
4610         tr->terminal_rsp_data.select_item.device_id.src = DEVICE_ID_ME;
4611         tr->terminal_rsp_data.select_item.device_id.dest = DEVICE_ID_SIM;
4612
4613         switch (confirm_type) {
4614                 case USER_CONFIRM_YES:
4615                         tr->terminal_rsp_data.select_item.item_identifier.item_identifier = item_id;
4616                         tr->terminal_rsp_data.select_item.other_info = FALSE;
4617                         tr->terminal_rsp_data.select_item.result_type = RESULT_SUCCESS;
4618                         tr->terminal_rsp_data.select_item.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
4619
4620                         if(q_data.cmd_data.selectItemInd.text_attribute.b_txt_attr || q_data.cmd_data.selectItemInd.text_attribute_list.list_cnt > 0)
4621                                 tr->terminal_rsp_data.select_item.result_type = RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION;
4622
4623                         if (q_data.cmd_data.selectItemInd.icon_id.is_exist)
4624                                 tr->terminal_rsp_data.select_item.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
4625
4626                         break;
4627
4628                 case USER_CONFIRM_HELP_INFO:
4629                         tr->terminal_rsp_data.select_item.item_identifier.item_identifier = item_id;
4630                         tr->terminal_rsp_data.select_item.other_info = FALSE;
4631                         tr->terminal_rsp_data.select_item.result_type = RESULT_HELP_INFO_REQUIRED_BY_USER;
4632                         tr->terminal_rsp_data.select_item.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
4633                         //TODO ctx->help_requested = TRUE;
4634                         break;
4635
4636                 case USER_CONFIRM_END:
4637                         tr->terminal_rsp_data.select_item.result_type = RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER;
4638                         break;
4639
4640                 case USER_CONFIRM_NO_OR_CANCEL:
4641                         tr->terminal_rsp_data.select_item.result_type = RESULT_BACKWARD_MOVE_BY_USER;
4642                         break;
4643
4644                 case USER_CONFIRM_TIMEOUT:
4645                         tr->terminal_rsp_data.select_item.result_type = RESULT_NO_RESPONSE_FROM_USER;
4646                         break;
4647
4648                 default:
4649                         dbg("not handled value[%d] here", confirm_type);
4650                         break;
4651         }
4652
4653         result = TRUE;
4654         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
4655         if(rv != TCORE_RETURN_SUCCESS){
4656                 dbg("fail to send terminal response");
4657                 result = FALSE;
4658         }
4659
4660         g_free(tr);
4661
4662         return result;
4663 }
4664
4665 static gboolean _sat_manager_handle_display_text_confirm(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gint confirm_type, GVariant *addtional_data)
4666 {
4667         TReturn rv = TCORE_RETURN_FAILURE;
4668         gboolean result = FALSE;
4669
4670         struct treq_sat_terminal_rsp_data *tr;
4671         struct sat_manager_queue_data q_data;
4672
4673         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
4674
4675         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
4676                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
4677                 return result;
4678         }
4679
4680         if (!plg){
4681                 dbg("there is no valid plugin at this point");
4682                 return result;
4683         }
4684
4685         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
4686         if (!tr)
4687                 return result;
4688         tr->cmd_number = q_data.cmd_data.displayTextInd.command_detail.cmd_num;
4689         tr->cmd_type = q_data.cmd_data.displayTextInd.command_detail.cmd_type;
4690         memcpy((void*)&tr->terminal_rsp_data.display_text.command_detail, &q_data.cmd_data.displayTextInd.command_detail, sizeof(struct tel_sat_cmd_detail_info));
4691         tr->terminal_rsp_data.display_text.device_id.src = DEVICE_ID_ME;
4692         tr->terminal_rsp_data.display_text.device_id.dest = DEVICE_ID_SIM;
4693
4694         switch (confirm_type){
4695                 case USER_CONFIRM_YES: {
4696                         tr->terminal_rsp_data.display_text.result_type = RESULT_SUCCESS;
4697                         tr->terminal_rsp_data.display_text.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
4698
4699                         if(q_data.cmd_data.displayTextInd.text_attribute.b_txt_attr)
4700                                 tr->terminal_rsp_data.display_text.result_type = RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION;
4701
4702                         if (q_data.cmd_data.displayTextInd.icon_id.is_exist)
4703                                 tr->terminal_rsp_data.display_text.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
4704                 } break;
4705
4706                 case USER_CONFIRM_NO_OR_CANCEL:
4707                         tr->terminal_rsp_data.display_text.result_type = RESULT_BACKWARD_MOVE_BY_USER;
4708                         break;
4709
4710                 case USER_CONFIRM_TIMEOUT:
4711                         tr->terminal_rsp_data.display_text.result_type = RESULT_SUCCESS;
4712
4713                         if (q_data.cmd_data.displayTextInd.command_detail.cmd_qualifier.display_text.text_clear_type == TEXT_WAIT_FOR_USER_TO_CLEAR_MSG )
4714                                 tr->terminal_rsp_data.display_text.result_type = RESULT_NO_RESPONSE_FROM_USER;
4715
4716                         break;
4717
4718                 case USER_CONFIRM_END:
4719                         tr->terminal_rsp_data.display_text.result_type = RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER;
4720                         break;
4721
4722                 case USER_CONFIRM_HELP_INFO:
4723                 default:
4724                         dbg("not handled value[%d] here", confirm_type);
4725                         break;
4726         }
4727
4728         result = TRUE;
4729         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
4730         if(rv != TCORE_RETURN_SUCCESS){
4731                 dbg("fail to send terminal response");
4732                 result = FALSE;
4733         }
4734
4735         g_free(tr);
4736
4737         return result;
4738 }
4739
4740 static gboolean _sat_manager_handle_get_inkey_confirm(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gint confirm_type, GVariant *addtional_data)
4741 {
4742         TReturn rv = TCORE_RETURN_FAILURE;
4743         gboolean result = FALSE;
4744
4745         gint inkey_data_len = 0;
4746         gchar inkey_data[SAT_TEXT_STRING_LEN_MAX];
4747         struct treq_sat_terminal_rsp_data *tr;
4748         struct sat_manager_queue_data q_data;
4749
4750         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
4751         memset(inkey_data, 0, SAT_TEXT_STRING_LEN_MAX);
4752
4753         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
4754                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
4755                 return result;
4756         }
4757
4758         if (!plg){
4759                 dbg("there is no valid plugin at this point");
4760                 return result;
4761         }
4762
4763         if(addtional_data){
4764                 int local_index = 0;
4765                 guchar data;
4766                 GVariantIter *iter = NULL;
4767                 GVariant *inner_gv = NULL;
4768
4769                 inner_gv = g_variant_get_variant(addtional_data);
4770                 dbg("additional data exist type_format(%s)", g_variant_get_type_string(inner_gv));
4771
4772                 g_variant_get(inner_gv, "ay", &iter);
4773                 while( g_variant_iter_loop (iter, "y", &data)){
4774                         dbg("index(%d) data(%d)", local_index, data);
4775                         inkey_data[local_index] = data;
4776                         local_index++;
4777                 }
4778                 g_variant_iter_free(iter);
4779                 g_variant_unref(inner_gv);
4780                 inkey_data_len = local_index;
4781         }
4782
4783         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
4784         if (!tr)
4785                 return result;
4786         tr->cmd_number = q_data.cmd_data.getInkeyInd.command_detail.cmd_num;
4787         tr->cmd_type = q_data.cmd_data.getInkeyInd.command_detail.cmd_type;
4788         memcpy((void*)&tr->terminal_rsp_data.get_inkey.command_detail, &q_data.cmd_data.getInkeyInd.command_detail, sizeof(struct tel_sat_cmd_detail_info));
4789         tr->terminal_rsp_data.get_inkey.device_id.src = DEVICE_ID_ME;
4790         tr->terminal_rsp_data.get_inkey.device_id.dest = DEVICE_ID_SIM;
4791
4792         switch (confirm_type){
4793                 case USER_CONFIRM_YES:
4794                         tr->terminal_rsp_data.get_inkey.result_type = RESULT_SUCCESS;
4795
4796                         if(q_data.cmd_data.getInkeyInd.text_attribute.b_txt_attr)
4797                                 tr->terminal_rsp_data.get_inkey.result_type = RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION;
4798
4799                         if (q_data.cmd_data.getInkeyInd.icon_id.is_exist)
4800                                 tr->terminal_rsp_data.get_inkey.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
4801
4802                         if (q_data.cmd_data.getInkeyInd.command_detail.cmd_qualifier.get_inkey.inkey_type == INKEY_TYPE_YES_NO_REQUESTED) {
4803                                 tr->terminal_rsp_data.get_inkey.text.dcs.m_class = MSG_CLASS_RESERVED;
4804                                 tr->terminal_rsp_data.get_inkey.text.dcs.a_format = ALPHABET_FORMAT_8BIT_DATA;
4805                                 tr->terminal_rsp_data.get_inkey.text.string_length = 1;
4806                                 tr->terminal_rsp_data.get_inkey.text.string[0] = 0x01;
4807                         }
4808                         else if(inkey_data_len > 0)
4809                         {
4810                                 tr->terminal_rsp_data.get_inkey.text.string_length = inkey_data_len;
4811
4812                                 if (!q_data.cmd_data.getInkeyInd.command_detail.cmd_qualifier.get_inkey.alphabet_set){
4813                                         tr->terminal_rsp_data.get_inkey.text.is_digit_only = TRUE;
4814                                         tr->terminal_rsp_data.get_inkey.text.dcs.a_format = ALPHABET_FORMAT_8BIT_DATA;
4815                                         tr->terminal_rsp_data.get_inkey.text.dcs.m_class = MSG_CLASS_RESERVED;
4816
4817                                         memcpy((void*)tr->terminal_rsp_data.get_inkey.text.string, inkey_data, inkey_data_len);
4818                                 }
4819                                 else
4820                                 {
4821                                         tr->terminal_rsp_data.get_inkey.text.dcs.m_class = MSG_CLASS_RESERVED;
4822
4823                                         if(q_data.cmd_data.getInkeyInd.command_detail.cmd_qualifier.get_inkey.alphabet_type == INPUT_ALPHABET_TYPE_SMS_DEFAULT )
4824                                         {
4825                                                 int tmp_len;
4826                                                 char tmp_str[SAT_TEXT_STRING_LEN_MAX + 1], *packed_data;
4827
4828                                                 dbg("sat gsm7 encoding");
4829                                                 tcore_util_convert_utf8_to_gsm((unsigned char*) tmp_str, &tmp_len, (unsigned char*)inkey_data, inkey_data_len);
4830                                                 packed_data = (char*) tcore_util_pack_gsm7bit((const unsigned char *)tmp_str, tmp_len);
4831
4832                                                 if(packed_data){
4833                                                         tr->terminal_rsp_data.get_inkey.text.dcs.a_format = ALPHABET_FORMAT_8BIT_DATA;
4834                                                         tr->terminal_rsp_data.get_inkey.text.string_length = strlen(packed_data);
4835                                                         memcpy((void*) tr->terminal_rsp_data.get_inkey.text.string, packed_data, strlen(packed_data));
4836
4837                                                         g_free(packed_data);
4838                                                 }
4839                                         }
4840                                         else if(q_data.cmd_data.getInkeyInd.command_detail.cmd_qualifier.get_inkey.alphabet_type == INPUT_ALPHABET_TYPE_UCS2 )
4841                                         {
4842                                                 char *tmp = NULL;
4843                                                 dbg("UCS2 DATA");
4844
4845                                                 tr->terminal_rsp_data.get_inkey.text.dcs.a_format = ALPHABET_FORMAT_UCS2;
4846                                                 tcore_util_convert_utf8_to_ucs2(&tmp,
4847                                                                 &tr->terminal_rsp_data.get_inkey.text.string_length, (unsigned char*)inkey_data, inkey_data_len);
4848
4849                                                 memcpy(tr->terminal_rsp_data.get_inkey.text.string, tmp, tr->terminal_rsp_data.get_inkey.text.string_length);
4850                                                 g_free(tmp);
4851                                         }
4852                                         else
4853                                         {
4854                                                 tr->terminal_rsp_data.get_inkey.text.dcs.a_format = ALPHABET_FORMAT_RESERVED;
4855                                                 dbg("[SAT] invalid DCS[%d]",tr->terminal_rsp_data.get_inkey.text.dcs.a_format);
4856                                         }
4857                                 }
4858                         }
4859                         break;
4860
4861                 case USER_CONFIRM_HELP_INFO:
4862                         tr->terminal_rsp_data.get_inkey.result_type = RESULT_HELP_INFO_REQUIRED_BY_USER;
4863                         //TODO ctx->help_requested = TRUE;
4864                         break;
4865
4866                 case USER_CONFIRM_NO_OR_CANCEL:
4867                         tr->terminal_rsp_data.get_inkey.result_type = RESULT_BACKWARD_MOVE_BY_USER;
4868
4869                         if (q_data.cmd_data.getInkeyInd.command_detail.cmd_qualifier.get_inkey.inkey_type == INKEY_TYPE_YES_NO_REQUESTED) {
4870                                 tr->terminal_rsp_data.get_inkey.result_type = RESULT_SUCCESS;
4871                                 tr->terminal_rsp_data.get_inkey.text.dcs.m_class = MSG_CLASS_RESERVED;
4872                                 tr->terminal_rsp_data.get_inkey.text.dcs.a_format = ALPHABET_FORMAT_8BIT_DATA;
4873                                 tr->terminal_rsp_data.get_inkey.text.string_length = 1;
4874                                 tr->terminal_rsp_data.get_inkey.text.string[0] = 0x00;
4875                         }
4876                         break;
4877
4878                 case USER_CONFIRM_TIMEOUT:
4879                         tr->terminal_rsp_data.get_inkey.result_type = RESULT_NO_RESPONSE_FROM_USER;
4880                         break;
4881
4882                 case USER_CONFIRM_END:
4883                         tr->terminal_rsp_data.get_inkey.result_type = RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER;
4884                         break;
4885
4886                 default:
4887                         dbg("not handled value[%d] here", confirm_type);
4888                         break;
4889         }
4890
4891         result = TRUE;
4892         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
4893         if(rv != TCORE_RETURN_SUCCESS){
4894                 dbg("fail to send terminal response");
4895                 result = FALSE;
4896         }
4897
4898         g_free(tr);
4899
4900         return result;
4901 }
4902
4903 static gboolean _sat_manager_handle_get_input_confirm(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gint confirm_type, GVariant *addtional_data)
4904 {
4905         TReturn rv = TCORE_RETURN_FAILURE;
4906         gboolean result = FALSE;
4907
4908         gint input_data_len = 0;
4909         gchar input_data[SAT_TEXT_STRING_LEN_MAX];
4910         struct treq_sat_terminal_rsp_data *tr;
4911         struct sat_manager_queue_data q_data;
4912
4913         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
4914         memset(input_data, 0, SAT_TEXT_STRING_LEN_MAX);
4915
4916         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
4917                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
4918                 return result;
4919         }
4920
4921         if (!plg){
4922                 dbg("there is no valid plugin at this point");
4923                 return result;
4924         }
4925
4926         if(addtional_data){
4927                 int local_index = 0;
4928                 guchar data;
4929                 GVariantIter *iter = NULL;
4930                 GVariant *inner_gv = NULL;
4931
4932                 inner_gv = g_variant_get_variant(addtional_data);
4933                 dbg("additional data exist type_format(%s)", g_variant_get_type_string(inner_gv));
4934
4935                 g_variant_get(inner_gv, "ay", &iter);
4936                 while( g_variant_iter_loop (iter, "y", &data)){
4937                         dbg("index(%d) data(%d)", local_index, data);
4938                         input_data[local_index] = data;
4939                         local_index++;
4940                 }
4941                 g_variant_iter_free(iter);
4942                 g_variant_unref(inner_gv);
4943                 input_data_len = local_index;
4944         }
4945
4946         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
4947         if (!tr)
4948                 return result;
4949
4950         tr->cmd_number = q_data.cmd_data.getInputInd.command_detail.cmd_num;
4951         tr->cmd_type = q_data.cmd_data.getInputInd.command_detail.cmd_type;
4952         memcpy((void*)&tr->terminal_rsp_data.get_input.command_detail, &q_data.cmd_data.getInputInd.command_detail, sizeof(struct tel_sat_cmd_detail_info));
4953         tr->terminal_rsp_data.get_input.device_id.src = DEVICE_ID_ME;
4954         tr->terminal_rsp_data.get_input.device_id.dest = DEVICE_ID_SIM;
4955
4956         switch (confirm_type){
4957                 case USER_CONFIRM_YES:
4958                         tr->terminal_rsp_data.get_input.result_type = RESULT_SUCCESS;
4959                         tr->terminal_rsp_data.get_input.text.dcs.m_class = MSG_CLASS_RESERVED;
4960
4961                         if(!q_data.cmd_data.getInputInd.command_detail.cmd_qualifier.get_input.alphabet_set){
4962                                 tr->terminal_rsp_data.get_input.text.is_digit_only = TRUE;
4963                         }
4964
4965                         if(q_data.cmd_data.getInputInd.text_attribute.b_txt_attr)
4966                                 tr->terminal_rsp_data.get_input.result_type = RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION;
4967
4968                         if (q_data.cmd_data.getInputInd.icon_id.is_exist)
4969                                 tr->terminal_rsp_data.get_input.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
4970
4971                         if(!q_data.cmd_data.getInputInd.command_detail.cmd_qualifier.get_input.user_input_unpacked_format){
4972                                 dbg("[SAT] packing to SMS7 default");
4973
4974                                 tr->terminal_rsp_data.get_input.text.string_length = 0;
4975                                 tr->terminal_rsp_data.get_input.text.dcs.a_format = ALPHABET_FORMAT_SMS_DEFAULT;
4976
4977                                 if (input_data_len > 0){
4978                                         int tmp_len;
4979                                         char tmp_str[SAT_TEXT_STRING_LEN_MAX + 1], *packed_data;
4980
4981                                         dbg("sat gsm7 encoding");
4982                                         tcore_util_convert_utf8_to_gsm((unsigned char*)tmp_str, &tmp_len, (unsigned char*)input_data, input_data_len);
4983                                         packed_data = (char*) tcore_util_pack_gsm7bit((const unsigned char *)tmp_str, tmp_len);
4984
4985                                         if(packed_data){
4986                                                 memcpy((void*)tr->terminal_rsp_data.get_input.text.string, packed_data, strlen(packed_data));
4987                                                 tr->terminal_rsp_data.get_input.text.string_length = strlen(packed_data);
4988
4989                                                 g_free(packed_data);
4990                                         }
4991                                 }
4992
4993                         }
4994                         else
4995                         {
4996                                 dbg("[SAT] packing not required");
4997
4998                                 if(q_data.cmd_data.getInkeyInd.command_detail.cmd_qualifier.get_input.alphabet_type == INPUT_ALPHABET_TYPE_SMS_DEFAULT){
4999
5000                                         tr->terminal_rsp_data.get_input.text.dcs.a_format = ALPHABET_FORMAT_8BIT_DATA;
5001                                         tcore_util_convert_utf8_to_gsm((unsigned char*)tr->terminal_rsp_data.get_input.text.string,
5002                                                         &tr->terminal_rsp_data.get_input.text.string_length, (unsigned char*)input_data, input_data_len);
5003
5004                                 }
5005                                 else if(q_data.cmd_data.getInkeyInd.command_detail.cmd_qualifier.get_input.alphabet_type == INPUT_ALPHABET_TYPE_UCS2 ){
5006                                         char *tmp = NULL;
5007
5008                                         tr->terminal_rsp_data.get_input.text.dcs.a_format = ALPHABET_FORMAT_UCS2;
5009                                         tcore_util_convert_utf8_to_ucs2(&tmp, &tr->terminal_rsp_data.get_input.text.string_length, (unsigned char*)input_data, input_data_len);
5010
5011                                         memcpy(tr->terminal_rsp_data.get_input.text.string, tmp, tr->terminal_rsp_data.get_input.text.string_length);
5012                                         g_free(tmp);
5013                                 }
5014                                 else{
5015                                         tr->terminal_rsp_data.get_input.text.dcs.a_format = ALPHABET_FORMAT_RESERVED;
5016                                         dbg("[SAT] invalid DCS[%d]",tr->terminal_rsp_data.get_input.text.dcs.a_format);
5017                                 }
5018                         } break;
5019
5020                 case USER_CONFIRM_HELP_INFO:
5021                         tr->terminal_rsp_data.get_input.result_type = RESULT_HELP_INFO_REQUIRED_BY_USER;
5022                         //TODO ctx->help_requested = TRUE;
5023                         break;
5024
5025                 case USER_CONFIRM_NO_OR_CANCEL:
5026                         tr->terminal_rsp_data.get_input.result_type = RESULT_BACKWARD_MOVE_BY_USER;
5027                         break;
5028
5029                 case USER_CONFIRM_TIMEOUT:
5030                         tr->terminal_rsp_data.get_input.result_type = RESULT_NO_RESPONSE_FROM_USER;
5031                         break;
5032
5033                 case USER_CONFIRM_END:
5034                         tr->terminal_rsp_data.get_input.result_type = RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER;
5035                         break;
5036                 default:
5037                         break;
5038         }
5039
5040         result = TRUE;
5041         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
5042         if(rv != TCORE_RETURN_SUCCESS){
5043                 dbg("fail to send terminal response");
5044                 result = FALSE;
5045         }
5046
5047         g_free(tr);
5048
5049         return result;
5050 }
5051
5052 static gboolean _sat_manager_handle_setup_call_confirm(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gint confirm_type, GVariant *addtional_data)
5053 {
5054         TReturn rv = TCORE_RETURN_FAILURE;
5055         gboolean result = FALSE;
5056
5057         gint input_data_len = 0;
5058         gchar input_data[SAT_TEXT_STRING_LEN_MAX];
5059         struct treq_sat_terminal_rsp_data *tr;
5060         struct sat_manager_queue_data q_data;
5061
5062         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
5063         memset(input_data, 0, SAT_TEXT_STRING_LEN_MAX);
5064
5065         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
5066                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
5067                 return result;
5068         }
5069
5070         if (!plg){
5071                 dbg("there is no valid plugin at this point");
5072                 return result;
5073         }
5074
5075         if (addtional_data) {
5076                 int local_index = 0;
5077                 guchar data;
5078                 GVariantIter *iter = NULL;
5079                 GVariant *inner_gv = NULL;
5080
5081                 inner_gv = g_variant_get_variant(addtional_data);
5082                 dbg("additional data exist type_format(%s)", g_variant_get_type_string(inner_gv));
5083
5084                 g_variant_get(inner_gv, "ay", &iter);
5085                 while( g_variant_iter_loop (iter, "y", &data)){
5086                         dbg("index(%d) data(%d)", local_index, data);
5087                         input_data[local_index] = data;
5088                         local_index++;
5089                 }
5090                 g_variant_iter_free(iter);
5091                 g_variant_unref(inner_gv);
5092                 input_data_len = local_index;
5093                 dbg("input_data_len=[%d]", input_data_len);
5094         }
5095
5096         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
5097         if (!tr)
5098                 return result;
5099
5100         tr->cmd_number = q_data.cmd_data.setup_call.command_detail.cmd_num;
5101         tr->cmd_type = q_data.cmd_data.setup_call.command_detail.cmd_type;
5102         memcpy((void*)&tr->terminal_rsp_data.setup_call.command_detail, &q_data.cmd_data.setup_call.command_detail, sizeof(struct tel_sat_cmd_detail_info));
5103         tr->terminal_rsp_data.setup_call.device_id.src = DEVICE_ID_ME;
5104         tr->terminal_rsp_data.setup_call.device_id.dest = q_data.cmd_data.setup_call.device_id.src;
5105
5106         switch(confirm_type){
5107                 case USER_CONFIRM_YES:{
5108                         char *path;
5109                         TelephonySAT *sat;
5110                         TelephonyObjectSkeleton *object;
5111
5112                         const gchar *cp_name;
5113                         GVariant *setup_call = NULL;
5114
5115                         gint command_id, call_type, confirmed_text_len, text_len, duration;
5116                         gchar *confirmed_text = NULL, *text = NULL, *call_number = NULL;
5117 #if defined(TIZEN_SUPPORT_SAT_ICON)
5118                         GVariant *icon_id;
5119 #endif
5120                         enum dbus_tapi_sim_slot_id slot_id;
5121                         gboolean call_app_rv;
5122
5123                         cp_name = tcore_server_get_cp_name_by_plugin(plg);
5124                         if (cp_name == NULL) {
5125                                 err("CP name is NULL");
5126                                 goto Exit;
5127                         }
5128
5129                         dbg("CP Name: [%s]", cp_name);
5130                         path = g_strdup_printf("%s/%s", MY_DBUS_PATH, cp_name);
5131
5132                         /* Look-up Hash table for Object */
5133                         object = g_hash_table_lookup(ctx->objects, path);
5134                         dbg("Path: [%s] Interface object: [%p]", path, object);
5135                         g_free(path);
5136                         if (object == NULL) {
5137                                 err("Object is NOT defined!!!");
5138                                 goto Exit;
5139                         }
5140
5141                         sat = telephony_object_peek_sat(TELEPHONY_OBJECT(object));
5142
5143                         setup_call = sat_manager_setup_call_noti(ctx, cp_name, &q_data.cmd_data.setup_call);
5144
5145                         dbg("setup call type_format(%s)", g_variant_get_type_string(setup_call));
5146 #if defined(TIZEN_SUPPORT_SAT_ICON)
5147                         g_variant_get(setup_call, "(isisi@visi)", &command_id, &confirmed_text, &confirmed_text_len, &text, &text_len, &icon_id, &call_type, &call_number, &duration);
5148
5149                         telephony_sat_emit_setup_call(sat, command_id, confirmed_text, confirmed_text_len, text, text_len, icon_id, call_type,
5150                                         call_number, duration);
5151 #else
5152                         g_variant_get(setup_call, "(isisiisi)", &command_id, &confirmed_text, &confirmed_text_len, &text, &text_len, &call_type, &call_number, &duration);
5153
5154                         telephony_sat_emit_setup_call(sat, command_id, confirmed_text, confirmed_text_len, text, text_len, call_type,
5155                                         call_number, duration);
5156 #endif
5157                         g_free(confirmed_text);
5158                         g_free(text);
5159                         g_free(call_number);
5160
5161                         slot_id = get_sim_slot_id_by_cp_name((char *)tcore_server_get_cp_name_by_plugin(plg));
5162                         dbg("slot_id: [%d]", slot_id);
5163
5164                         call_app_rv = sat_ui_support_launch_call_application(q_data.cmd_data.setup_call.command_detail.cmd_type, setup_call, slot_id);
5165                         free (tr);
5166
5167                         return call_app_rv;
5168                 }
5169
5170                 case USER_CONFIRM_NO_OR_CANCEL:{
5171                         tr->terminal_rsp_data.setup_call.result_type = RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER;
5172                 }break;
5173
5174                 case USER_CONFIRM_END:{
5175                         tr->terminal_rsp_data.setup_call.result_type = RESULT_USER_DID_NOT_ACCEPT_CALL_SETUP_REQ;
5176                 }break;
5177
5178                 case USER_CONFIRM_HELP_INFO:
5179                 default:
5180                         tr->terminal_rsp_data.setup_call.result_type = RESULT_NO_RESPONSE_FROM_USER;
5181                 break;
5182         }
5183
5184         result = TRUE;
5185         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
5186         if(rv != TCORE_RETURN_SUCCESS){
5187                 dbg("fail to send terminal response");
5188                 result = FALSE;
5189         }
5190 Exit:
5191         free (tr);
5192         return result;
5193 }
5194
5195 static gboolean _sat_manager_handle_send_dtmf_confirm(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gint confirm_type, GVariant *addtional_data)
5196 {
5197         TReturn rv = TCORE_RETURN_FAILURE;
5198         gboolean result = FALSE;
5199
5200         struct treq_sat_terminal_rsp_data *tr;
5201         struct sat_manager_queue_data q_data;
5202
5203         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
5204
5205         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
5206                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
5207                 return result;
5208         }
5209
5210         if (!plg){
5211                 dbg("there is no valid plugin at this point");
5212                 return result;
5213         }
5214
5215         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
5216         if (!tr)
5217                 return result;
5218
5219         tr->cmd_number = q_data.cmd_data.send_dtmf.command_detail.cmd_num;
5220         tr->cmd_type = q_data.cmd_data.send_dtmf.command_detail.cmd_type;
5221         memcpy((void*)&tr->terminal_rsp_data.send_dtmf.command_detail, &q_data.cmd_data.send_dtmf.command_detail, sizeof(struct tel_sat_cmd_detail_info));
5222         tr->terminal_rsp_data.send_dtmf.device_id.src = DEVICE_ID_ME;
5223         tr->terminal_rsp_data.send_dtmf.device_id.dest = q_data.cmd_data.send_dtmf.device_id.src;
5224
5225         dbg("confirm_type[%d]", confirm_type);
5226
5227         switch(confirm_type){
5228                 case USER_CONFIRM_NO_OR_CANCEL:
5229                 case USER_CONFIRM_END:
5230                         tr->terminal_rsp_data.send_dtmf.result_type = RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER;
5231                         tr->terminal_rsp_data.send_dtmf.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
5232                         break;
5233                 default:
5234                         tr->terminal_rsp_data.send_dtmf.result_type = RESULT_NO_RESPONSE_FROM_USER;
5235                         break;
5236         }
5237
5238         result = TRUE;
5239         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
5240         if(rv != TCORE_RETURN_SUCCESS){
5241                 dbg("fail to send terminal response");
5242                 result = FALSE;
5243         }
5244         g_free(tr);
5245
5246         return result;
5247 }
5248
5249 static gboolean _sat_manager_handle_launch_browser_confirm(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gint confirm_type, GVariant *addtional_data)
5250 {
5251         TReturn rv = TCORE_RETURN_FAILURE;
5252         gboolean result = FALSE;
5253
5254         struct treq_sat_terminal_rsp_data *tr;
5255         struct sat_manager_queue_data q_data;
5256
5257         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
5258
5259         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
5260                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
5261                 return result;
5262         }
5263
5264         if (!plg){
5265                 dbg("there is no valid plugin at this point");
5266                 return result;
5267         }
5268
5269         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
5270         if (!tr)
5271                 return result;
5272
5273         tr->cmd_number = q_data.cmd_data.launch_browser.command_detail.cmd_num;
5274         tr->cmd_type = q_data.cmd_data.launch_browser.command_detail.cmd_type;
5275         memcpy((void*)&tr->terminal_rsp_data.launch_browser.command_detail, &q_data.cmd_data.launch_browser.command_detail, sizeof(struct tel_sat_cmd_detail_info));
5276         tr->terminal_rsp_data.launch_browser.device_id.src = q_data.cmd_data.launch_browser.device_id.dest;
5277         tr->terminal_rsp_data.launch_browser.device_id.dest = q_data.cmd_data.launch_browser.device_id.src;
5278
5279         dbg("confirm_type[%d]", confirm_type);
5280
5281         switch(confirm_type){
5282                 case USER_CONFIRM_YES:{
5283                         char *path;
5284                         TelephonySAT *sat;
5285                         TelephonyObjectSkeleton *object;
5286
5287                         const gchar *cp_name;
5288                         GVariant *launch_browser = NULL;
5289
5290                         gint command_id = 0;
5291                         gint browser_launch_type = 0, browser_id = 0;
5292                         gint url_len = 0, text_len = 0, gateway_proxy_len =0;
5293                         gchar *url = NULL;
5294                         gchar *text = NULL;
5295                         gchar *gateway_proxy = NULL;
5296 #if defined(TIZEN_SUPPORT_SAT_ICON)
5297                         GVariant *icon_id = NULL;
5298 #endif
5299                         enum dbus_tapi_sim_slot_id slot_id;
5300
5301                         cp_name = tcore_server_get_cp_name_by_plugin(plg);
5302                         if (cp_name == NULL) {
5303                                 err("CP name is NULL");
5304                                 goto Exit;
5305                         }
5306
5307                         dbg("CP Name: [%s]", cp_name);
5308                         path = g_strdup_printf("%s/%s", MY_DBUS_PATH, cp_name);
5309
5310                         /* Look-up Hash table for Object */
5311                         object = g_hash_table_lookup(ctx->objects, path);
5312                         dbg("Path: [%s] Interface object: [%p]", path, object);
5313                         g_free(path);
5314                         if (object == NULL) {
5315                                 err("Object is NOT defined!!!");
5316                                 goto Exit;
5317                         }
5318                         sat = telephony_object_peek_sat(TELEPHONY_OBJECT(object));
5319
5320                         launch_browser = sat_manager_launch_browser_noti(ctx, cp_name, &q_data.cmd_data.launch_browser);
5321
5322                         dbg("launch_browser type_format(%s)", g_variant_get_type_string(launch_browser));
5323 #if defined(TIZEN_SUPPORT_SAT_ICON)
5324                         g_variant_get(launch_browser, "(iiisisisi@v)", &command_id, &browser_launch_type, &browser_id, &url, &url_len, &gateway_proxy, &gateway_proxy_len, &text, &text_len, &icon_id);
5325
5326                         telephony_sat_emit_launch_browser(sat, command_id, browser_launch_type, browser_id, url, url_len, gateway_proxy, gateway_proxy_len, text, text_len, icon_id);
5327 #else
5328                         g_variant_get(launch_browser, "(iiisisisi)", &command_id, &browser_launch_type, &browser_id, &url, &url_len, &gateway_proxy, &gateway_proxy_len, &text, &text_len);
5329
5330                         telephony_sat_emit_launch_browser(sat, command_id, browser_launch_type, browser_id, url, url_len, gateway_proxy, gateway_proxy_len, text, text_len);
5331 #endif
5332                         g_free(url);
5333                         g_free(text);
5334                         g_free(gateway_proxy);
5335
5336                         slot_id = get_sim_slot_id_by_cp_name((char*)tcore_server_get_cp_name_by_plugin(plg));
5337                         dbg("slot_id: [%d]", slot_id);
5338
5339                         sat_ui_support_launch_browser_application(q_data.cmd_data.launch_browser.command_detail.cmd_type, launch_browser, slot_id);
5340
5341                         g_free(tr);
5342                         return TRUE;
5343                 }break;
5344
5345                 case USER_CONFIRM_NO_OR_CANCEL:
5346                         tr->terminal_rsp_data.launch_browser.result_type = RESULT_BACKWARD_MOVE_BY_USER;
5347                         break;
5348                 case USER_CONFIRM_END:
5349                         tr->terminal_rsp_data.launch_browser.result_type = RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER;
5350                         break;
5351
5352                 default:
5353                         tr->terminal_rsp_data.launch_browser.result_type = RESULT_NO_RESPONSE_FROM_USER;
5354                         break;
5355         }
5356
5357         result = TRUE;
5358         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
5359         if(rv != TCORE_RETURN_SUCCESS){
5360                 dbg("fail to send terminal response");
5361                 result = FALSE;
5362         }
5363 Exit:
5364         g_free(tr);
5365         return result;
5366 }
5367 #if !defined(TIZEN_PLATFORM_USE_QCOM_QMI)
5368 static gboolean _sat_manager_handle_open_channel_confirm(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gint confirm_type, GVariant *addtional_data)
5369 {
5370         TReturn rv = TCORE_RETURN_FAILURE;
5371         gboolean result = FALSE;
5372
5373         struct treq_sat_terminal_rsp_data *tr;
5374         struct sat_manager_queue_data q_data;
5375
5376         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
5377
5378         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
5379                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
5380                 return result;
5381         }
5382
5383         if (!plg){
5384                 dbg("there is no valid plugin at this point");
5385                 return result;
5386         }
5387
5388         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
5389         if (!tr)
5390                 return result;
5391
5392         tr->cmd_number = q_data.cmd_data.open_channel.command_detail.cmd_num;
5393         tr->cmd_type = q_data.cmd_data.open_channel.command_detail.cmd_type;
5394         memcpy((void*)&tr->terminal_rsp_data.open_channel.command_detail, &q_data.cmd_data.open_channel.command_detail, sizeof(struct tel_sat_cmd_detail_info));
5395         tr->terminal_rsp_data.open_channel.device_id.src = q_data.cmd_data.send_dtmf.device_id.dest;
5396         tr->terminal_rsp_data.open_channel.device_id.dest = q_data.cmd_data.send_dtmf.device_id.src;
5397
5398         dbg("confirm_type[%d]", confirm_type);
5399
5400         switch(confirm_type){
5401                 case USER_CONFIRM_YES:{
5402                         char *path;
5403                         TelephonyObjectSkeleton *object;
5404
5405                         const gchar *cp_name;
5406
5407                         GVariant *open_channel = NULL;
5408
5409                         gint command_id, bearer_type, protocol_type, dest_addr_type;
5410                         gboolean immediate_link, auto_reconnection, bg_mode;
5411                         gint text_len, buffer_size, port_number;
5412                         gchar *text = NULL, *dest_address = NULL;
5413 #if defined(TIZEN_SUPPORT_SAT_ICON)
5414                         GVariant *icon_id;
5415 #endif
5416                         GVariant *bearer_param;
5417                         GVariant *bearer_detail;
5418
5419                         //emit send_dtmf signal
5420                         cp_name = tcore_server_get_cp_name_by_plugin(plg);
5421                         if (cp_name == NULL) {
5422                                 err("CP name is NULL");
5423                                 goto Exit;
5424                         }
5425
5426                         dbg("CP Name: [%s]", cp_name);
5427                         path = g_strdup_printf("%s/%s", MY_DBUS_PATH, cp_name);
5428
5429                         /* Look-up Hash table for Object */
5430                         object = g_hash_table_lookup(ctx->objects, path);
5431                         dbg("Path: [%s] Interface object: [%p]", path, object);
5432                         g_free(path);
5433                         if (object == NULL) {
5434                                 err("Object is NOT defined!!!");
5435                                 goto Exit;
5436                         }
5437
5438                         open_channel = sat_manager_open_channel_noti(ctx, cp_name, &q_data.cmd_data.open_channel);
5439
5440                         dbg("open channel type_format(%s)", g_variant_get_type_string(open_channel));
5441 #if defined(TIZEN_SUPPORT_SAT_ICON)
5442                         g_variant_get(open_channel,"(isi@vbbbi@viiiis@v)", &command_id, &text, &text_len, &icon_id, &immediate_link, &auto_reconnection, &bg_mode,
5443                                         &bearer_type, &bearer_param, &buffer_size, &protocol_type, &port_number, &dest_addr_type, &dest_address, &bearer_detail);
5444 #else
5445                         g_variant_get(open_channel,"(isibbbi@viiiis@v)", &command_id, &text, &text_len, &immediate_link, &auto_reconnection, &bg_mode,
5446                                         &bearer_type, &bearer_param, &buffer_size, &protocol_type, &port_number, &dest_addr_type, &dest_address, &bearer_detail);
5447 #endif
5448                         /*telephony_sat_emit_open_channel(sat, command_id, text, text_len, immediate_link, auto_reconnection, bg_mode,
5449                                         bearer_type, bearer_param, buffer_size, protocol_type, port_number, dest_addr_type, dest_address, bearer_detail);*/
5450
5451                         g_free(text);
5452                         g_free(dest_address);
5453                         //BIP Manager
5454                         {
5455                                 GDBusConnection *conn = NULL;
5456                                 const gchar *g_path = NULL;
5457
5458                                 conn = g_dbus_object_manager_server_get_connection(ctx->manager);
5459                                 g_path = g_dbus_object_get_object_path(G_DBUS_OBJECT(object));
5460
5461                                 sat_ui_support_exec_bip(conn, g_path, SAT_PROATV_CMD_OPEN_CHANNEL, open_channel);
5462                         }
5463
5464                         g_free(tr);
5465
5466                         return TRUE;
5467                 }break;
5468
5469                 case USER_CONFIRM_NO_OR_CANCEL:
5470                 case USER_CONFIRM_END:
5471                         tr->terminal_rsp_data.open_channel.result_type = RESULT_USER_DID_NOT_ACCEPT_CALL_SETUP_REQ;
5472                         break;
5473                 default:
5474                         tr->terminal_rsp_data.open_channel.result_type = RESULT_NO_RESPONSE_FROM_USER;
5475                         break;
5476         }
5477
5478         memcpy((void*)&tr->terminal_rsp_data.open_channel.bearer_desc, &q_data.cmd_data.open_channel.bearer_desc, sizeof(struct tel_sat_bearer_description));
5479         memcpy((void*)&tr->terminal_rsp_data.open_channel.buffer_size, &q_data.cmd_data.open_channel.buffer_size, sizeof(struct tel_sat_buffer_size));
5480
5481         result = TRUE;
5482         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
5483         if(rv != TCORE_RETURN_SUCCESS){
5484                 dbg("fail to send terminal response");
5485                 result = FALSE;
5486         }
5487 Exit:
5488         g_free(tr);
5489         return result;
5490 }
5491 #else
5492 static gboolean _sat_manager_handle_open_channel_confirm(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gint confirm_type, GVariant *addtional_data)
5493 {
5494         TReturn rv = TCORE_RETURN_FAILURE;
5495         gboolean result = FALSE;
5496
5497         struct treq_sat_user_confirmation_data *conf_data;
5498         struct sat_manager_queue_data q_data;
5499
5500         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
5501
5502         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
5503                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
5504                 return result;
5505         }
5506
5507         if (!plg){
5508                 dbg("there is no valid plugin at this point");
5509                 return result;
5510         }
5511
5512         conf_data = (struct treq_sat_user_confirmation_data *)calloc(1, sizeof(struct treq_sat_user_confirmation_data));
5513         if (!conf_data)
5514                 return result;
5515
5516         dbg("confirm_type[%d]", confirm_type);
5517
5518         switch(confirm_type){
5519                 case USER_CONFIRM_YES:
5520                 case USER_CONFIRM_NO_OR_CANCEL:
5521                 case USER_CONFIRM_END:
5522                         conf_data->user_conf = confirm_type;
5523                         break;
5524                 default:
5525                         dbg("Not handled confirm type!");
5526                         break;
5527         }
5528         result = TRUE;
5529         rv = sat_manager_send_user_confirmation(ctx->comm, plg, conf_data);
5530         if(rv != TCORE_RETURN_SUCCESS){
5531                 dbg("fail to send user confirmation message");
5532                 result = FALSE;
5533         }
5534         g_free(conf_data);
5535         return result;
5536 }
5537 #endif
5538 gboolean sat_manager_handle_user_confirm(struct custom_data *ctx, TcorePlugin *plg, GVariant *user_confirm_data)
5539 {
5540         gboolean rv = FALSE;
5541         gboolean result = FALSE;
5542         struct sat_manager_queue_data q_data;
5543
5544         gint command_id, command_type, confirm_type;
5545         GVariant *additional_data = NULL;
5546
5547         dbg("user_confirm_data type_format(%s)", g_variant_get_type_string(user_confirm_data));
5548         g_variant_get(user_confirm_data, "(iiv)", &command_id, &confirm_type, &additional_data);
5549
5550         dbg("[SAT] user confirm data command id(%d), confirm_type(%d)", command_id, confirm_type);
5551
5552         rv = sat_manager_queue_peek_data_by_id(ctx, &q_data, command_id);
5553         if(!rv){
5554                 dbg("[SAT] no commands in queue");
5555                 return result;
5556         }
5557
5558         command_type = (gint)q_data.cmd_type;
5559         dbg("[SAT] command type(%d)", command_type);
5560
5561         switch(command_type){
5562                 case SAT_PROATV_CMD_SELECT_ITEM:
5563                         result = _sat_manager_handle_menu_select_confirm(ctx, plg, command_id, confirm_type, additional_data);
5564                         break;
5565                 case SAT_PROATV_CMD_DISPLAY_TEXT:
5566                         result = _sat_manager_handle_display_text_confirm(ctx, plg, command_id, confirm_type, additional_data);
5567                         break;
5568                 case SAT_PROATV_CMD_GET_INKEY:
5569                         result = _sat_manager_handle_get_inkey_confirm(ctx, plg, command_id, confirm_type, additional_data);
5570                         break;
5571                 case SAT_PROATV_CMD_GET_INPUT:
5572                         result = _sat_manager_handle_get_input_confirm(ctx, plg, command_id, confirm_type, additional_data);
5573                         break;
5574                 case SAT_PROATV_CMD_SETUP_CALL:
5575                         result = _sat_manager_handle_setup_call_confirm(ctx, plg, command_id, confirm_type, additional_data);
5576                         break;
5577                 case SAT_PROATV_CMD_SEND_DTMF:
5578                         result = _sat_manager_handle_send_dtmf_confirm(ctx, plg, command_id, confirm_type, additional_data);
5579                         break;
5580                 case SAT_PROATV_CMD_LAUNCH_BROWSER:
5581                         result = _sat_manager_handle_launch_browser_confirm(ctx, plg, command_id, confirm_type, additional_data);
5582                         break;
5583                 case SAT_PROATV_CMD_OPEN_CHANNEL:
5584                         result = _sat_manager_handle_open_channel_confirm(ctx, plg, command_id, confirm_type, additional_data);
5585                         break;
5586                 default:
5587                         dbg("[SAT] cannot handle user confirm command(0x%x)", command_type);
5588                         break;
5589         }
5590
5591         return result;
5592 }
5593
5594 static gboolean _sat_manager_handle_play_tone_ui_display_status(struct custom_data *ctx, TcorePlugin *plg,struct sat_manager_queue_data *q_data, gboolean display_status)
5595 {
5596         char *path;
5597         TelephonySAT *sat;
5598         TelephonyObjectSkeleton *object;
5599
5600         const gchar *cp_name;
5601         GVariant *play_tone = NULL;
5602
5603
5604         gint command_id, tone_type, duration;
5605         gint text_len;
5606         gchar* text;
5607 #if defined(TIZEN_SUPPORT_SAT_ICON)
5608         GVariant *icon_id;
5609 #endif
5610         if(!display_status){
5611                 struct treq_sat_terminal_rsp_data *tr = NULL;
5612                 dbg("[SAT] fail to show ui display for play tone");
5613
5614                 tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
5615                 if (!tr)
5616                         return FALSE;
5617
5618                 tr->cmd_number = q_data->cmd_data.play_tone.command_detail.cmd_num;
5619                 tr->cmd_type = q_data->cmd_data.play_tone.command_detail.cmd_type;
5620                 memcpy((void*)&tr->terminal_rsp_data.play_tone.command_detail, &q_data->cmd_data.play_tone.command_detail, sizeof(struct tel_sat_cmd_detail_info));
5621
5622                 tr->terminal_rsp_data.play_tone.device_id.src = DEVICE_ID_ME;
5623                 tr->terminal_rsp_data.play_tone.device_id.dest = q_data->cmd_data.play_tone.device_id.src;
5624                 tr->terminal_rsp_data.play_tone.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
5625
5626                 sat_manager_send_terminal_response(ctx->comm, plg, tr);
5627                 free (tr);
5628
5629                 return TRUE;
5630         }
5631
5632         //emit play tone signal
5633         cp_name = tcore_server_get_cp_name_by_plugin(plg);
5634         if (cp_name == NULL) {
5635                 err("CP name is NULL");
5636                 return FALSE;
5637         }
5638
5639         dbg("CP Name: [%s]", cp_name);
5640         path = g_strdup_printf("%s/%s", MY_DBUS_PATH, cp_name);
5641
5642         /* Look-up Hash table for Object */
5643         object = g_hash_table_lookup(ctx->objects, path);
5644         dbg("Path: [%s] Interface object: [%p]", path, object);
5645         g_free(path);
5646         if (object == NULL) {
5647                 err("Object is NOT defined!!!");
5648                 return FALSE;
5649         }
5650         sat = telephony_object_peek_sat(TELEPHONY_OBJECT(object));
5651
5652         play_tone = sat_manager_play_tone_noti(ctx, cp_name, &q_data->cmd_data.play_tone);
5653
5654         dbg("play tone type_format(%s)", g_variant_get_type_string(play_tone));
5655 #if defined(TIZEN_SUPPORT_SAT_ICON)
5656         g_variant_get(play_tone, "(isi@vii)", &command_id, &text, &text_len, &icon_id, &tone_type, &duration);
5657
5658         telephony_sat_emit_play_tone(sat, command_id, text, text_len, icon_id, tone_type, duration);
5659 #else
5660         g_variant_get(play_tone, "(isiii)", &command_id, &text, &text_len, &tone_type, &duration);
5661
5662         telephony_sat_emit_play_tone(sat, command_id, text, text_len, tone_type, duration);
5663 #endif
5664         g_free(text);
5665
5666         return TRUE;
5667 }
5668
5669 static gboolean _sat_manager_handle_setup_idle_mode_text_ui_display_status(struct custom_data *ctx, TcorePlugin *plg,struct sat_manager_queue_data *q_data, gboolean display_status)
5670 {
5671         TReturn rv = TCORE_RETURN_FAILURE;
5672         gboolean result = FALSE;
5673
5674         struct treq_sat_terminal_rsp_data *tr;
5675
5676         if (!plg){
5677                 dbg("there is no valid plugin at this point");
5678                 return result;
5679         }
5680
5681         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
5682         if (!tr)
5683                 return result;
5684
5685         tr->cmd_number = q_data->cmd_data.idle_mode.command_detail.cmd_num;
5686         tr->cmd_type = q_data->cmd_data.idle_mode.command_detail.cmd_type;
5687         memcpy((void*)&tr->terminal_rsp_data.setup_idle_mode_text.command_detail, &q_data->cmd_data.idle_mode.command_detail, sizeof(struct tel_sat_cmd_detail_info));
5688         tr->terminal_rsp_data.setup_idle_mode_text.device_id.src = q_data->cmd_data.idle_mode.device_id.dest;
5689         tr->terminal_rsp_data.setup_idle_mode_text.device_id.dest = q_data->cmd_data.idle_mode.device_id.src;
5690
5691         tr->terminal_rsp_data.setup_idle_mode_text.result_type = RESULT_SUCCESS;
5692         if (q_data->cmd_data.idle_mode.icon_id.is_exist)
5693                 tr->terminal_rsp_data.setup_idle_mode_text.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
5694
5695         //fail to display text
5696         if(!display_status){
5697                 dbg("[SAT] fail to show ui display for setup_idle_mode_text");
5698                 tr->terminal_rsp_data.setup_idle_mode_text.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
5699         }
5700
5701         result = TRUE;
5702         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
5703         if(rv != TCORE_RETURN_SUCCESS){
5704                 dbg("fail to send terminal response");
5705                 result = FALSE;
5706         }
5707         g_free(tr);
5708
5709         return result;
5710 }
5711
5712 static gboolean _sat_manager_handle_refresh_ui_display_status(struct custom_data *ctx, TcorePlugin *plg,struct sat_manager_queue_data *q_data, gboolean display_status)
5713 {
5714         struct treq_sat_terminal_rsp_data tr;
5715
5716         memset(&tr, 0, sizeof(struct treq_sat_terminal_rsp_data));
5717
5718         tr.cmd_number = q_data->cmd_data.refresh.command_detail.cmd_num;
5719         tr.cmd_type = q_data->cmd_data.refresh.command_detail.cmd_type;
5720         memcpy((void*)&tr.terminal_rsp_data.refresh.command_detail, &q_data->cmd_data.refresh.command_detail, sizeof(struct tel_sat_cmd_detail_info));
5721         tr.terminal_rsp_data.refresh.device_id.src = q_data->cmd_data.refresh.device_id.dest;
5722         tr.terminal_rsp_data.refresh.device_id.dest = q_data->cmd_data.refresh.device_id.src;
5723
5724         if(!display_status){
5725                 dbg("fail to show ui for refresh");
5726                 tr.terminal_rsp_data.refresh.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
5727         }
5728         else{
5729                 dbg("success to show ui for refresh");
5730                 tr.terminal_rsp_data.refresh.result_type = RESULT_SUCCESS;
5731                 tr.terminal_rsp_data.refresh.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
5732         }
5733
5734         dbg("send refresh tr");
5735         sat_manager_send_terminal_response(ctx->comm, plg, &tr);
5736         return TRUE;
5737 }
5738
5739
5740 #if !defined(TIZEN_PLATFORM_USE_QCOM_QMI)
5741 static gboolean _sat_manager_handle_send_sms_ui_display_status(struct custom_data *ctx, TcorePlugin *plg,struct sat_manager_queue_data *q_data, gboolean display_status)
5742 {
5743         char *path;
5744         TelephonySAT *sat;
5745         TelephonyObjectSkeleton *object;
5746
5747         const char *cp_name;
5748         GVariant *send_sms = NULL;
5749
5750         gint command_id, ton, npi, tpdu_type;
5751         gboolean b_packing_required;
5752         gint text_len, number_len, tpdu_data_len;
5753         gchar* text, *dialling_number;
5754         GVariant *tpdu_data;
5755 #if defined(TIZEN_SUPPORT_SAT_ICON)
5756         GVariant *icon_id;
5757 #endif
5758
5759         if(!display_status){
5760                 struct treq_sat_terminal_rsp_data *tr = NULL;
5761                 dbg("[SAT] fail to show ui display for send sms");
5762
5763                 tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
5764                 if (!tr)
5765                         return FALSE;
5766
5767                 tr->cmd_number = q_data->cmd_data.sendSMSInd.command_detail.cmd_num;
5768                 tr->cmd_type = q_data->cmd_data.sendSMSInd.command_detail.cmd_type;
5769                 memcpy((void*)&tr->terminal_rsp_data.send_sms.command_detail, &q_data->cmd_data.sendSMSInd.command_detail, sizeof(struct tel_sat_cmd_detail_info));
5770
5771                 tr->terminal_rsp_data.send_sms.device_id.src = DEVICE_ID_ME;
5772                 tr->terminal_rsp_data.send_sms.device_id.dest = q_data->cmd_data.sendSMSInd.device_id.src;
5773                 tr->terminal_rsp_data.send_sms.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
5774
5775                 sat_manager_send_terminal_response(ctx->comm, plg, tr);
5776                 free (tr);
5777
5778                 return TRUE;
5779         }
5780
5781         //emit send sms signal
5782         cp_name = tcore_server_get_cp_name_by_plugin(plg);
5783         if (cp_name == NULL) {
5784                 err("CP name is NULL");
5785                 return FALSE;
5786         }
5787
5788         dbg("CP Name: [%s]", cp_name);
5789         path = g_strdup_printf("%s/%s", MY_DBUS_PATH, cp_name);
5790
5791         /* Look-up Hash table for Object */
5792         object = g_hash_table_lookup(ctx->objects, path);
5793         dbg("Path: [%s] Interface object: [%p]", path, object);
5794         g_free(path);
5795         if (object == NULL) {
5796                 err("Object is NOT defined!!!");
5797                 return FALSE;
5798         }
5799         sat = telephony_object_peek_sat(TELEPHONY_OBJECT(object));
5800
5801         send_sms = sat_manager_send_sms_noti(ctx, cp_name, &q_data->cmd_data.sendSMSInd);
5802
5803         dbg("send sms type_format(%s)", g_variant_get_type_string(send_sms));
5804 #if defined(TIZEN_SUPPORT_SAT_ICON)
5805         g_variant_get(send_sms, "(isi@vbiisii@vi)", &command_id, &text, &text_len, &icon_id, &b_packing_required, &ton, &npi,
5806                         &dialling_number, &number_len, &tpdu_type, &tpdu_data, &tpdu_data_len);
5807 #else
5808         g_variant_get(send_sms, "(isibiisii@vi)", &command_id, &text, &text_len, &b_packing_required, &ton, &npi,
5809                         &dialling_number, &number_len, &tpdu_type, &tpdu_data, &tpdu_data_len);
5810 #endif
5811         telephony_sat_emit_send_sms(sat, command_id, text, text_len, b_packing_required,
5812                         ton, npi, dialling_number, number_len, tpdu_type, tpdu_data, tpdu_data_len);
5813
5814         g_free(text);
5815         g_free(dialling_number);
5816         return TRUE;
5817 }
5818
5819 static gboolean _sat_manager_handle_send_ss_ui_display_status(struct custom_data *ctx, TcorePlugin *plg,struct sat_manager_queue_data *q_data, gboolean display_status)
5820 {
5821         char *path;
5822         TelephonySAT *sat;
5823         TelephonyObjectSkeleton *object;
5824
5825         const gchar *cp_name;
5826         GVariant *send_ss = NULL;
5827
5828         gint command_id, ton, npi;
5829         gint text_len, ss_str_len;
5830         gchar* text = NULL, *ss_string = NULL;
5831 #if defined(TIZEN_SUPPORT_SAT_ICON)
5832         GVariant *icon_id;
5833 #endif
5834         enum dbus_tapi_sim_slot_id slot_id;
5835
5836         if(!display_status){
5837                 struct treq_sat_terminal_rsp_data *tr = NULL;
5838                 dbg("[SAT] fail to show ui display for send ss");
5839
5840                 tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
5841                 if (!tr)
5842                         return FALSE;
5843
5844                 tr->cmd_number = q_data->cmd_data.send_ss.command_detail.cmd_num;
5845                 tr->cmd_type = q_data->cmd_data.send_ss.command_detail.cmd_type;
5846                 memcpy((void*)&tr->terminal_rsp_data.send_ss.command_detail, &q_data->cmd_data.send_ss.command_detail, sizeof(struct tel_sat_cmd_detail_info));
5847
5848                 tr->terminal_rsp_data.send_ss.device_id.src = DEVICE_ID_ME;
5849                 tr->terminal_rsp_data.send_ss.device_id.dest = q_data->cmd_data.send_ss.device_id.src;
5850                 tr->terminal_rsp_data.send_ss.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
5851
5852                 sat_manager_send_terminal_response(ctx->comm, plg, tr);
5853                 free (tr);
5854
5855                 return TRUE;
5856         }
5857
5858         //emit send ss signal
5859         cp_name = tcore_server_get_cp_name_by_plugin(plg);
5860         if (cp_name == NULL) {
5861                 err("CP name is NULL");
5862                 return FALSE;
5863         }
5864
5865         dbg("CP Name: [%s]", cp_name);
5866         path = g_strdup_printf("%s/%s", MY_DBUS_PATH, cp_name);
5867
5868         /* Look-up Hash table for Object */
5869         object = g_hash_table_lookup(ctx->objects, path);
5870         dbg("Path: [%s] Interface object: [%p]", path, object);
5871         g_free(path);
5872         if (object == NULL) {
5873                 err("Object is NOT defined!!!");
5874                 return FALSE;
5875         }
5876         sat = telephony_object_peek_sat(TELEPHONY_OBJECT(object));
5877
5878         send_ss = sat_manager_send_ss_noti(ctx, cp_name, &q_data->cmd_data.send_ss);
5879
5880         dbg("send ss type_format(%s)", g_variant_get_type_string(send_ss));
5881 #if defined(TIZEN_SUPPORT_SAT_ICON)
5882         g_variant_get(send_ss, "(isi@viiis)", &command_id, &text, &text_len, &icon_id,
5883                         &ton, &npi, &ss_str_len, &ss_string);
5884 #else
5885         g_variant_get(send_ss, "(isiiiis)", &command_id, &text, &text_len,
5886                         &ton, &npi, &ss_str_len, &ss_string);
5887 #endif
5888         telephony_sat_emit_send_ss(sat, command_id, text, text_len, ton, npi, ss_string);
5889         g_free(text);
5890         g_free(ss_string);
5891
5892         slot_id = get_sim_slot_id_by_cp_name((char *)tcore_server_get_cp_name_by_plugin(plg));
5893         dbg("slot_id: [%d]", slot_id);
5894         sat_ui_support_launch_ciss_application(SAT_PROATV_CMD_SEND_SS, send_ss, slot_id);
5895
5896         return TRUE;
5897 }
5898
5899 static gboolean _sat_manager_handle_send_ussd_ui_display_status(struct custom_data *ctx, TcorePlugin *plg,struct sat_manager_queue_data *q_data, gboolean display_status)
5900 {
5901         char *path;
5902         TelephonySAT *sat;
5903         TelephonyObjectSkeleton *object;
5904
5905         const gchar *cp_name;
5906         GVariant *send_ussd = NULL;
5907
5908         gint command_id;
5909         guchar dcs;
5910         gint text_len, ussd_str_len;
5911         gchar* text = NULL, *ussd_string = NULL;
5912 #if defined(TIZEN_SUPPORT_SAT_ICON)
5913         GVariant *icon_id;
5914 #endif
5915         enum dbus_tapi_sim_slot_id slot_id;
5916
5917         if(!display_status){
5918                 struct treq_sat_terminal_rsp_data *tr = NULL;
5919                 dbg("[SAT] fail to show ui display for send ussd");
5920
5921                 tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
5922                 if (!tr)
5923                         return FALSE;
5924
5925                 tr->cmd_number = q_data->cmd_data.send_ussd.command_detail.cmd_num;
5926                 tr->cmd_type = q_data->cmd_data.send_ussd.command_detail.cmd_type;
5927                 memcpy((void*)&tr->terminal_rsp_data.send_ussd.command_detail, &q_data->cmd_data.send_ussd.command_detail, sizeof(struct tel_sat_cmd_detail_info));
5928
5929                 tr->terminal_rsp_data.send_ussd.device_id.src = DEVICE_ID_ME;
5930                 tr->terminal_rsp_data.send_ussd.device_id.dest = q_data->cmd_data.send_ussd.device_id.src;
5931                 tr->terminal_rsp_data.send_ussd.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
5932
5933                 sat_manager_send_terminal_response(ctx->comm, plg, tr);
5934                 g_free(tr);
5935
5936                 return TRUE;
5937         }
5938
5939         //emit send ussd signal
5940         cp_name = tcore_server_get_cp_name_by_plugin(plg);
5941         if (cp_name == NULL) {
5942                 err("CP name is NULL");
5943                 return FALSE;
5944         }
5945
5946         dbg("CP Name: [%s]", cp_name);
5947         path = g_strdup_printf("%s/%s", MY_DBUS_PATH, cp_name);
5948
5949         /* Look-up Hash table for Object */
5950         object = g_hash_table_lookup(ctx->objects, path);
5951         dbg("Path: [%s] Interface object: [%p]", path, object);
5952         g_free(path);
5953         if (object == NULL) {
5954                 err("Object is NOT defined!!!");
5955                 return FALSE;
5956         }
5957         sat = telephony_object_peek_sat(TELEPHONY_OBJECT(object));
5958
5959         send_ussd = sat_manager_send_ussd_noti(ctx, cp_name, &q_data->cmd_data.send_ussd);
5960
5961         dbg("send ussd type_format(%s)", g_variant_get_type_string(send_ussd));
5962 #if defined(TIZEN_SUPPORT_SAT_ICON)
5963         g_variant_get(send_ussd, "(isi@vyis)", &command_id, &text, &text_len, &icon_id, &dcs, &ussd_str_len, &ussd_string);
5964 #else
5965         g_variant_get(send_ussd, "(isiyis)", &command_id, &text, &text_len, &dcs, &ussd_str_len, &ussd_string);
5966 #endif
5967         telephony_sat_emit_setup_ussd(sat, command_id, text, text_len, dcs, ussd_string);
5968         g_free(text);
5969         g_free(ussd_string);
5970
5971         slot_id = get_sim_slot_id_by_cp_name((char *)tcore_server_get_cp_name_by_plugin(plg));
5972         dbg("slot_id: [%d]", slot_id);
5973         sat_ui_support_launch_ciss_application(SAT_PROATV_CMD_SEND_USSD, send_ussd,slot_id);
5974
5975         return TRUE;
5976 }
5977
5978 static gboolean _sat_manager_handle_send_dtmf_ui_display_status(struct custom_data *ctx, TcorePlugin *plg,struct sat_manager_queue_data *q_data, gboolean display_status)
5979 {
5980         char *path;
5981         TelephonySAT *sat;
5982         TelephonyObjectSkeleton *object;
5983
5984         const gchar *cp_name;
5985
5986         GVariant *send_dtmf = NULL;
5987         gint command_id = 0;
5988         gint text_len = 0, dtmf_str_len = 0;
5989         gchar *text = NULL;
5990         gchar *dtmf_str = NULL;
5991 #if defined(TIZEN_SUPPORT_SAT_ICON)
5992         GVariant *icon_id = NULL;
5993 #endif
5994         if(!display_status){
5995                 struct treq_sat_terminal_rsp_data *tr = NULL;
5996                 dbg("[SAT] fail to show ui display for send_dtmf");
5997
5998                 tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
5999                 if (!tr)
6000                         return FALSE;
6001
6002                 tr->cmd_number = q_data->cmd_data.send_dtmf.command_detail.cmd_num;
6003                 tr->cmd_type = q_data->cmd_data.send_dtmf.command_detail.cmd_type;
6004                 memcpy((void*)&tr->terminal_rsp_data.send_dtmf.command_detail, &q_data->cmd_data.send_dtmf.command_detail, sizeof(struct tel_sat_cmd_detail_info));
6005
6006                 tr->terminal_rsp_data.send_dtmf.device_id.src = DEVICE_ID_ME;
6007                 tr->terminal_rsp_data.send_dtmf.device_id.dest = q_data->cmd_data.send_dtmf.device_id.src;
6008                 tr->terminal_rsp_data.send_dtmf.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
6009
6010                 sat_manager_send_terminal_response(ctx->comm, plg, tr);
6011                 g_free(tr);
6012
6013                 return TRUE;
6014         }
6015
6016         //emit send_dtmf signal
6017         cp_name = tcore_server_get_cp_name_by_plugin(plg);
6018         if (cp_name == NULL) {
6019                 err("CP name is NULL");
6020                 return FALSE;
6021         }
6022
6023         dbg("CP Name: [%s]", cp_name);
6024         path = g_strdup_printf("%s/%s", MY_DBUS_PATH, cp_name);
6025
6026         /* Look-up Hash table for Object */
6027         object = g_hash_table_lookup(ctx->objects, path);
6028         dbg("Path: [%s] Interface object: [%p]", path, object);
6029         g_free(path);
6030         if (object == NULL) {
6031                 err("Object is NOT defined!!!");
6032                 return FALSE;
6033         }
6034         sat = telephony_object_peek_sat(TELEPHONY_OBJECT(object));
6035
6036         send_dtmf = sat_manager_send_dtmf_noti(ctx, cp_name, &q_data->cmd_data.send_dtmf);
6037
6038         dbg("send_dtmf type_format(%s)", g_variant_get_type_string(send_dtmf));
6039 #if defined(TIZEN_SUPPORT_SAT_ICON)
6040         g_variant_get(send_dtmf, "(isi@vis)", &command_id, &text, &text_len, &icon_id, &dtmf_str_len, &dtmf_str);
6041 #else
6042         g_variant_get(send_dtmf, "(isiis)", &command_id, &text, &text_len, &dtmf_str_len, &dtmf_str);
6043 #endif
6044         telephony_sat_emit_send_dtmf(sat, command_id, text, text_len, dtmf_str, dtmf_str_len);
6045         g_free(text);
6046         g_free(dtmf_str);
6047
6048         return TRUE;
6049 }
6050
6051 static gboolean _sat_manager_handle_open_channel_ui_display_status(struct custom_data *ctx, TcorePlugin *plg,struct sat_manager_queue_data *q_data, gboolean display_status)
6052 {
6053         char *path;
6054         TelephonyObjectSkeleton *object;
6055
6056         const gchar *cp_name;
6057
6058         GVariant *open_channel = NULL;
6059
6060         gint command_id, bearer_type, protocol_type, dest_addr_type;
6061         gboolean immediate_link, auto_reconnection, bg_mode;
6062         gint text_len, buffer_size, port_number;
6063         gchar *text, *dest_address;
6064         GVariant *bearer_param;
6065         GVariant *bearer_detail;
6066 #if defined(TIZEN_SUPPORT_SAT_ICON)
6067         GVariant *icon_id;
6068 #endif
6069
6070         if(!display_status){
6071                 struct treq_sat_terminal_rsp_data *tr = NULL;
6072                 dbg("[SAT] fail to show ui display for open channel");
6073
6074                 tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
6075                 if (!tr)
6076                         return FALSE;
6077
6078                 tr->cmd_number = q_data->cmd_data.open_channel.command_detail.cmd_num;
6079                 tr->cmd_type = q_data->cmd_data.open_channel.command_detail.cmd_type;
6080                 memcpy((void*)&tr->terminal_rsp_data.open_channel.command_detail, &q_data->cmd_data.open_channel.command_detail, sizeof(struct tel_sat_cmd_detail_info));
6081
6082                 tr->terminal_rsp_data.open_channel.device_id.src = q_data->cmd_data.send_dtmf.device_id.dest;
6083                 tr->terminal_rsp_data.open_channel.device_id.dest = q_data->cmd_data.send_dtmf.device_id.src;
6084                 tr->terminal_rsp_data.open_channel.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
6085
6086                 sat_manager_send_terminal_response(ctx->comm, plg, tr);
6087                 g_free(tr);
6088
6089                 return TRUE;
6090         }
6091
6092         //emit send_dtmf signal
6093         cp_name = tcore_server_get_cp_name_by_plugin(plg);
6094         if (cp_name == NULL) {
6095                 err("CP name is NULL");
6096                 return FALSE;
6097         }
6098
6099         dbg("CP Name: [%s]", cp_name);
6100         path = g_strdup_printf("%s/%s", MY_DBUS_PATH, cp_name);
6101
6102         /* Look-up Hash table for Object */
6103         object = g_hash_table_lookup(ctx->objects, path);
6104         dbg("Path: [%s] Interface object: [%p]", path, object);
6105         g_free(path);
6106         if (object == NULL) {
6107                 err("Object is NOT defined!!!");
6108                 return FALSE;
6109         }
6110
6111         open_channel = sat_manager_open_channel_noti(ctx, cp_name, &q_data->cmd_data.open_channel);
6112
6113         dbg("open channel type_format(%s)", g_variant_get_type_string(open_channel));
6114 #if defined(TIZEN_SUPPORT_SAT_ICON)
6115         g_variant_get(open_channel,"(isi@vbbbi@viiiis@v)", &command_id, &text, &text_len, &icon_id, &immediate_link, &auto_reconnection, &bg_mode,
6116                         &bearer_type, &bearer_param, &buffer_size, &protocol_type, &port_number, &dest_addr_type, &dest_address, &bearer_detail);
6117 #else
6118         g_variant_get(open_channel,"(isibbbi@viiiis@v)", &command_id, &text, &text_len, &immediate_link, &auto_reconnection, &bg_mode,
6119                         &bearer_type, &bearer_param, &buffer_size, &protocol_type, &port_number, &dest_addr_type, &dest_address, &bearer_detail);
6120 #endif
6121         /*telephony_sat_emit_open_channel(sat, command_id, text, text_len, immediate_link, auto_reconnection, bg_mode,
6122                         bearer_type, bearer_param, buffer_size, protocol_type, port_number, dest_addr_type, dest_address, bearer_detail);*/
6123         g_free(text);
6124         g_free(dest_address);
6125
6126         //BIP Manager
6127         {
6128                 GDBusConnection *conn = NULL;
6129                 const gchar *g_path = NULL;
6130
6131                 conn = g_dbus_object_manager_server_get_connection(ctx->manager);
6132                 g_path = g_dbus_object_get_object_path(G_DBUS_OBJECT(object));
6133
6134                 sat_ui_support_exec_bip(conn, g_path, SAT_PROATV_CMD_OPEN_CHANNEL, open_channel);
6135         }
6136
6137         return TRUE;
6138 }
6139
6140 gboolean sat_manager_handle_ui_display_status(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gboolean display_status)
6141 {
6142         gboolean result = FALSE;
6143         struct sat_manager_queue_data q_data;
6144
6145         dbg("[SAT] ui display status : command id(%d) display status(%d)", command_id, display_status);
6146         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
6147
6148         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
6149                 dbg("[SAT] command peek data from queue is failed. didn't find in command Q!!");
6150                 return result;
6151         }
6152
6153         if (!plg){
6154                 dbg("there is no valid plugin at this point");
6155                 return result;
6156         }
6157
6158         switch(q_data.cmd_type){
6159                 case SAT_PROATV_CMD_PLAY_TONE:
6160                         result = _sat_manager_handle_play_tone_ui_display_status(ctx, plg, &q_data, display_status);
6161                         break;
6162                 case SAT_PROATV_CMD_SEND_SMS:
6163                         result = _sat_manager_handle_send_sms_ui_display_status(ctx, plg, &q_data, display_status);
6164                         break;
6165                 case SAT_PROATV_CMD_SEND_SS:
6166                         result = _sat_manager_handle_send_ss_ui_display_status(ctx, plg, &q_data, display_status);
6167                         break;
6168                 case SAT_PROATV_CMD_SEND_USSD:
6169                         result = _sat_manager_handle_send_ussd_ui_display_status(ctx, plg, &q_data, display_status);
6170                         break;
6171                 case SAT_PROATV_CMD_SETUP_IDLE_MODE_TEXT:
6172                         result = _sat_manager_handle_setup_idle_mode_text_ui_display_status(ctx, plg, &q_data, display_status);
6173                         break;
6174                 case SAT_PROATV_CMD_REFRESH:
6175                         result = _sat_manager_handle_refresh_ui_display_status(ctx, plg, &q_data, display_status);
6176                         break;
6177                 case SAT_PROATV_CMD_SEND_DTMF:
6178                         result = _sat_manager_handle_send_dtmf_ui_display_status(ctx, plg, &q_data, display_status);
6179                         break;
6180                 case SAT_PROATV_CMD_OPEN_CHANNEL:
6181                         result = _sat_manager_handle_open_channel_ui_display_status(ctx, plg, &q_data, display_status);
6182                         break;
6183                 default:
6184                         dbg("[SAT] cannot handle ui display status command(0x%x)", q_data.cmd_type);
6185                         break;
6186         }
6187
6188         return result;
6189 }
6190 #else
6191 static gboolean _sat_manager_handle_open_channel_ui_display_status(struct custom_data *ctx, TcorePlugin *plg,struct sat_manager_queue_data *q_data, gboolean display_status)
6192 {
6193         TReturn rv = TCORE_RETURN_FAILURE;
6194         gboolean result = FALSE;
6195         struct treq_sat_user_confirmation_data *conf_data;
6196
6197         if (!plg){
6198                 dbg("there is no valid plugin at this point");
6199                 return result;
6200         }
6201
6202         conf_data = (struct treq_sat_user_confirmation_data *)calloc(1, sizeof(struct treq_sat_user_confirmation_data));
6203         if (!conf_data)
6204                 return result;
6205
6206         dbg("display_status[%d]", display_status);
6207
6208         if(display_status)
6209                 conf_data->user_conf = USER_CONFIRM_YES;
6210         else
6211                 conf_data->user_conf = USER_CONFIRM_NO_OR_CANCEL;
6212
6213         result = TRUE;
6214         rv = sat_manager_send_user_confirmation(ctx->comm, plg, conf_data);
6215         if(rv != TCORE_RETURN_SUCCESS){
6216                 dbg("fail to send user confirmation message");
6217                 result = FALSE;
6218         }
6219         g_free(conf_data);
6220         return result;
6221 }
6222
6223 gboolean sat_manager_handle_ui_display_status(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gboolean display_status)
6224 {
6225         gboolean result = FALSE;
6226         struct sat_manager_queue_data q_data;
6227
6228         dbg("[SAT] ui display status : command id(%d) display status(%d)", command_id, display_status);
6229         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
6230
6231         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
6232                 dbg("[SAT] command peek data from queue is failed. didn't find in command Q!!");
6233                 return result;
6234         }
6235
6236         if (!plg){
6237                 dbg("there is no valid plugin at this point");
6238                 return result;
6239         }
6240
6241         switch(q_data.cmd_type){
6242                 case SAT_PROATV_CMD_PLAY_TONE:
6243                         result = _sat_manager_handle_play_tone_ui_display_status(ctx, plg, &q_data, display_status);
6244                         break;
6245                 case SAT_PROATV_CMD_SETUP_IDLE_MODE_TEXT:
6246                         result = _sat_manager_handle_setup_idle_mode_text_ui_display_status(ctx, plg, &q_data, display_status);
6247                         break;
6248                 case SAT_PROATV_CMD_REFRESH:
6249                         result = _sat_manager_handle_refresh_ui_display_status(ctx, plg, &q_data, display_status);
6250                         break;
6251                 case SAT_PROATV_CMD_OPEN_CHANNEL:
6252                         result = _sat_manager_handle_open_channel_ui_display_status(ctx, plg, &q_data, display_status);
6253                         break;
6254                 case SAT_PROATV_CMD_SEND_SMS:
6255                 case SAT_PROATV_CMD_SEND_SS:
6256                 case SAT_PROATV_CMD_SEND_USSD:
6257                 case SAT_PROATV_CMD_SEND_DTMF:
6258                         dbg("[SAT] command(0x%x) will be handled by CP", q_data.cmd_type);
6259                         result = TRUE;
6260                         if(q_data.noti_required) {
6261                                 TelephonySAT *sat;
6262                                 TelephonyObjectSkeleton *object;
6263                                 const gchar *cp_name;
6264                                 gchar *path = NULL;
6265
6266                                 dbg("Noti flag is set, send session end evt.");
6267                                 //emit session end
6268
6269                                 cp_name = tcore_server_get_cp_name_by_plugin(plg);
6270                                 if (cp_name == NULL) {
6271                                         err("CP name is NULL");
6272                                         return FALSE;
6273                                 }
6274
6275                                 dbg("CP Name: [%s]", cp_name);
6276                                 path = g_strdup_printf("%s/%s", MY_DBUS_PATH, cp_name);
6277
6278                                 /* Look-up Hash table for Object */
6279                                 object = g_hash_table_lookup(ctx->objects, path);
6280                                 dbg("Path: [%s] Interface object: [%p]", path, object);
6281                                 g_free(path);
6282                                 if (object == NULL) {
6283                                         err("Object is NOT defined!!!");
6284                                         return FALSE;
6285                                 }
6286
6287                                 sat = telephony_object_peek_sat(TELEPHONY_OBJECT(object));
6288                                 telephony_sat_emit_end_proactive_session(sat, SAT_PROATV_CMD_TYPE_END_PROACTIVE_SESSION);
6289                         }
6290                         break;
6291                 default:
6292                         dbg("[SAT] cannot handle ui display status command(0x%x)", q_data.cmd_type);
6293                         break;
6294         }
6295         return result;
6296 }
6297
6298 #endif
6299 gboolean sat_manager_handle_event_download_envelop(int event_type,  int src_dev, int dest_dev, struct tel_sat_envelop_event_download_tlv *evt_download, GVariant *download_data)
6300 {
6301         gboolean rv = FALSE;
6302         GVariant *data = NULL;
6303
6304         dbg("download data type_format(%s)", g_variant_get_type_string(download_data));
6305         g_variant_get(download_data, "v", &data);
6306
6307
6308         if(g_evt_list[event_type] == TRUE){
6309                 dbg("event (%d) shoud be passed to sim", event_type);
6310                 rv = TRUE;
6311         }
6312
6313         if(!rv){
6314                 dbg("(%d) event does not requested by sim", event_type);
6315                 return FALSE;
6316         }
6317
6318         switch(event_type)
6319         {
6320                 case EVENT_USER_ACTIVITY:
6321                         dbg("data type_format(%s)", g_variant_get_type_string(data));
6322                         evt_download->device_identitie.src = src_dev;
6323                         evt_download->device_identitie.dest = dest_dev;
6324                         break;
6325                 case EVENT_IDLE_SCREEN_AVAILABLE:
6326                         dbg("data type_format(%s)", g_variant_get_type_string(data));
6327                         g_variant_get(data, "(b)", &evt_download->idle_screen);
6328                         evt_download->device_identitie.src = DEVICE_ID_DISPLAY;
6329                         evt_download->device_identitie.dest = dest_dev;
6330                         dbg("idle screen available (%d)", evt_download->idle_screen);
6331                         break;
6332                 case EVENT_LANGUAGE_SELECTION:
6333                         dbg("data type_format(%s)", g_variant_get_type_string(data));
6334                         g_variant_get(data, "(i)", &evt_download->language);
6335                         evt_download->device_identitie.src = src_dev;
6336                         evt_download->device_identitie.dest = dest_dev;
6337                         dbg("selected language (%d)", evt_download->language);
6338                         break;
6339                 case EVENT_BROWSER_TERMINATION:{
6340                         dbg("data type_format(%s)", g_variant_get_type_string(data));
6341                         g_variant_get(data, "(i)", &evt_download->browser_termination);
6342                         evt_download->device_identitie.src = src_dev;
6343                         evt_download->device_identitie.dest = dest_dev;
6344                         dbg("browser termination cause(%d)", evt_download->browser_termination);
6345                 } break;
6346                 case EVENT_DATA_AVAILABLE:{
6347                         gint channel_id, channel_status, channel_info, channel_data_len;
6348
6349                         dbg("data type_format(%s)", g_variant_get_type_string(data));
6350                         g_variant_get(data, "(iiii)", &channel_id, &channel_status, &channel_info, &channel_data_len);
6351                         evt_download->device_identitie.src = src_dev;
6352                         evt_download->device_identitie.dest = dest_dev;
6353                         evt_download->channel_status.channel_id = channel_id;
6354                         evt_download->channel_status.status = channel_status;
6355                         evt_download->channel_status.status_info = channel_info;
6356                         evt_download->channel_data_len.data_len = channel_data_len;
6357                         dbg("data available channel id (%d)", evt_download->channel_status.channel_id);
6358                 } break;
6359                 case EVENT_CHANNEL_STATUS:{
6360                         gint channel_id, channel_status, channel_info;
6361
6362                         dbg("data type_format(%s)", g_variant_get_type_string(data));
6363                         g_variant_get(data, "(iii)", &channel_id, &channel_status, &channel_info);
6364                         evt_download->device_identitie.src = src_dev;
6365                         evt_download->device_identitie.dest = dest_dev;
6366                         evt_download->channel_status.channel_id = channel_id;
6367                         evt_download->channel_status.status = channel_status;
6368                         evt_download->channel_status.status_info = channel_info;
6369
6370                 } break;
6371                 default :
6372                         dbg("not support download event (%d)", event_type);
6373                         break;
6374         }
6375
6376         return TRUE;
6377 }
6378
6379 gboolean sat_manager_update_language(struct custom_data *ctx, const char *cp_name, GVariant *language_noti)
6380 {
6381         Server *s = NULL;
6382         TcorePlugin *plg = NULL;
6383         static Storage *strg;
6384
6385         TReturn rv = TCORE_RETURN_FAILURE;
6386         gboolean result = FALSE;
6387         const gchar *lang_str = NULL;
6388         gint command_id, language;
6389         gboolean b_specified;
6390
6391         struct treq_sat_terminal_rsp_data *tr;
6392         struct sat_manager_queue_data q_data;
6393
6394         s = ctx->server;
6395         strg = tcore_server_find_storage(s, "vconf");
6396
6397         plg = tcore_server_find_plugin(ctx->server, cp_name);
6398         if (!plg){
6399                 dbg("there is no valid plugin at this point");
6400                 return result;
6401         }
6402
6403         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
6404
6405         dbg("language_noti type_format(%s)", g_variant_get_type_string(language_noti));
6406         g_variant_get(language_noti, "(iib)", &command_id, &language, &b_specified);
6407
6408         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
6409                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
6410                 return result;
6411         }
6412
6413         if(q_data.cmd_type != SAT_PROATV_CMD_LANGUAGE_NOTIFICATION){
6414                 dbg("[SAT] Language Noti dequeue failed. didn't find in command Q!!");
6415                 return result;
6416         }
6417
6418         if (b_specified) {
6419                 lang_str = _convert_sim_lang_to_string((enum tel_sim_language_type)language);
6420                 if(!lang_str){
6421                         dbg("language is not exist");
6422                 }
6423                 dbg("converted lang (%s)", lang_str);
6424
6425                 if(_sat_manager_check_language_set(lang_str)) {
6426                         dbg("supprted language, set vconf.");
6427                         result = tcore_storage_set_string(strg,STORAGE_KEY_LANGUAGE_SET, (const char*)lang_str);
6428                         if(!result){
6429                                 dbg("fail to update language");
6430                         }
6431                 }
6432         }
6433
6434         /* TR should be sent with success result
6435          * regardless of language is specified or not.
6436          */
6437         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
6438         if (!tr)
6439                 return FALSE;
6440
6441         tr->cmd_number = q_data.cmd_data.language_notification.command_detail.cmd_num;
6442         tr->cmd_type = q_data.cmd_data.language_notification.command_detail.cmd_type;
6443         memcpy((void*)&tr->terminal_rsp_data.language_notification.command_detail, &q_data.cmd_data.language_notification.command_detail, sizeof(struct tel_sat_cmd_detail_info));
6444         tr->terminal_rsp_data.language_notification.device_id.src = DEVICE_ID_ME;
6445         tr->terminal_rsp_data.language_notification.device_id.dest = DEVICE_ID_SIM;
6446         tr->terminal_rsp_data.language_notification.result_type = RESULT_SUCCESS;
6447
6448         result = TRUE;
6449         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
6450         if(rv != TCORE_RETURN_SUCCESS){
6451                 dbg("fail to send terminal response");
6452                 g_free(tr);
6453                 result = FALSE;
6454                 return result;
6455         }
6456
6457         g_free(tr);
6458         return result;
6459 }