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