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
2858                 tr->terminal_rsp_data.provide_local_info.other.language = lang_type;
2859                 } break;
2860         default: {
2861                 tr->terminal_rsp_data.provide_local_info.other_info = FALSE;
2862                 tr->terminal_rsp_data.provide_local_info.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
2863                 tr->terminal_rsp_data.provide_local_info.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
2864                 } break;
2865         }
2866
2867         sat_manager_send_terminal_response(ctx->comm, plg, tr);
2868         g_free(tr);
2869
2870         return provide_info;
2871 }
2872
2873 GVariant* sat_manager_language_notification_noti(struct custom_data *ctx, const char *cp_name, struct tel_sat_language_notification_tlv *language_notification_tlv)
2874 {
2875         TcorePlugin *plg = NULL;
2876         GVariant *language_noti = NULL;
2877         struct sat_manager_queue_data q_data;
2878
2879         gint command_id = 0;
2880         gint language = 0;
2881         gboolean b_specified = FALSE;
2882
2883         dbg("interpreting langauge notification");
2884
2885         plg = tcore_server_find_plugin(ctx->server, cp_name);
2886         if (!plg) {
2887                 dbg("there is no valid plugin at this point");
2888                 return NULL;
2889         }
2890
2891         if (language_notification_tlv->command_detail.cmd_qualifier.language_notification.specific_language == TRUE) {
2892                 b_specified = TRUE;
2893                 language = language_notification_tlv->language;
2894         } else {
2895                 b_specified = FALSE;
2896                 language = SIM_LANG_UNSPECIFIED;
2897         }
2898
2899         /* enqueue data and generate cmd_id */
2900         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
2901         q_data.cmd_type = SAT_PROATV_CMD_LANGUAGE_NOTIFICATION;
2902         q_data.cp_name = g_strdup(cp_name);
2903         memcpy((void*)&(q_data.cmd_data.language_notification), language_notification_tlv, sizeof(struct tel_sat_language_notification_tlv));
2904         sat_manager_enqueue_cmd(ctx, &q_data);
2905         g_free(q_data.cp_name);
2906         command_id = q_data.cmd_id;
2907
2908         language_noti = g_variant_new("(iib)", command_id, language, b_specified);
2909
2910         return language_noti;
2911 }
2912
2913 gboolean sat_manager_processing_unsupport_proactive_command(struct custom_data *ctx, const char *cp_name, struct tel_sat_unsupproted_command_tlv *unsupport_tlv)
2914 {
2915         TcorePlugin *plg = NULL;
2916         struct treq_sat_terminal_rsp_data tr;
2917
2918         dbg("[SAT] unsupport proactive command (%d)", unsupport_tlv->command_detail.cmd_type);
2919
2920         plg = tcore_server_find_plugin(ctx->server, cp_name);
2921         if (!plg) {
2922                 dbg("there is no valid plugin at this point");
2923                 return FALSE;
2924         }
2925
2926         memset(&tr, 0x00, sizeof(struct treq_sat_terminal_rsp_data));
2927         tr.cmd_number = unsupport_tlv->command_detail.cmd_num;
2928         tr.cmd_type = unsupport_tlv->command_detail.cmd_type;
2929
2930         memcpy((void*)&tr.terminal_rsp_data.unsupport_cmd.command_detail, &unsupport_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
2931         tr.terminal_rsp_data.unsupport_cmd.device_id.src = DEVICE_ID_ME;
2932         tr.terminal_rsp_data.unsupport_cmd.device_id.dest = DEVICE_ID_SIM;
2933         tr.terminal_rsp_data.unsupport_cmd.result_type = RESULT_BEYOND_ME_CAPABILITIES;
2934
2935         sat_manager_send_terminal_response(ctx->comm, plg, &tr);
2936
2937         return TRUE;
2938 }
2939
2940 gboolean sat_manager_handle_sat_ui_launch_fail(struct custom_data *ctx, const char *cp_name, struct tnoti_sat_proactive_ind *p_ind)
2941 {
2942         TReturn rv = TCORE_RETURN_FAILURE;
2943         TcorePlugin *plg = NULL;
2944         struct treq_sat_terminal_rsp_data tr;
2945
2946         dbg("[SAT] proactive command (%d)", p_ind->cmd_type);
2947
2948         plg = tcore_server_find_plugin(ctx->server, cp_name);
2949         if (!plg) {
2950                 dbg("there is no valid plugin at this point");
2951                 return FALSE;
2952         }
2953
2954         memset(&tr, 0x00, sizeof(struct treq_sat_terminal_rsp_data));
2955         tr.cmd_number = p_ind->cmd_number;
2956         tr.cmd_type = p_ind->cmd_type;
2957
2958         switch (p_ind->cmd_type) {
2959         case SAT_PROATV_CMD_DISPLAY_TEXT: {
2960                 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));
2961                 tr.terminal_rsp_data.display_text.device_id.src = DEVICE_ID_ME;
2962                 tr.terminal_rsp_data.display_text.device_id.dest = DEVICE_ID_SIM;
2963                 tr.terminal_rsp_data.display_text.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
2964         } break;
2965         case SAT_PROATV_CMD_SELECT_ITEM: {
2966                 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));
2967                 tr.terminal_rsp_data.select_item.device_id.src = DEVICE_ID_ME;
2968                 tr.terminal_rsp_data.select_item.device_id.dest = DEVICE_ID_SIM;
2969                 tr.terminal_rsp_data.select_item.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
2970         } break;
2971         case SAT_PROATV_CMD_GET_INKEY: {
2972                 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));
2973                 tr.terminal_rsp_data.get_inkey.device_id.src = DEVICE_ID_ME;
2974                 tr.terminal_rsp_data.get_inkey.device_id.dest = DEVICE_ID_SIM;
2975                 tr.terminal_rsp_data.get_inkey.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
2976         } break;
2977         case SAT_PROATV_CMD_GET_INPUT: {
2978                 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));
2979                 tr.terminal_rsp_data.get_input.device_id.src = DEVICE_ID_ME;
2980                 tr.terminal_rsp_data.get_input.device_id.dest = DEVICE_ID_SIM;
2981                 tr.terminal_rsp_data.get_input.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
2982         } break;
2983         case SAT_PROATV_CMD_PLAY_TONE: {
2984                 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));
2985                 tr.terminal_rsp_data.play_tone.device_id.src = DEVICE_ID_ME;
2986                 tr.terminal_rsp_data.play_tone.device_id.dest = DEVICE_ID_SIM;
2987                 tr.terminal_rsp_data.play_tone.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
2988         } break;
2989         case SAT_PROATV_CMD_SEND_SMS: {
2990                 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));
2991                 tr.terminal_rsp_data.send_sms.device_id.src = DEVICE_ID_ME;
2992                 tr.terminal_rsp_data.send_sms.device_id.dest = DEVICE_ID_SIM;
2993                 tr.terminal_rsp_data.send_sms.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
2994         } break;
2995         case SAT_PROATV_CMD_SEND_SS: {
2996                 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));
2997                 tr.terminal_rsp_data.send_ss.device_id.src = DEVICE_ID_ME;
2998                 tr.terminal_rsp_data.send_ss.device_id.dest = DEVICE_ID_SIM;
2999                 tr.terminal_rsp_data.send_ss.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
3000         } break;
3001         case SAT_PROATV_CMD_SEND_USSD: {
3002                 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));
3003                 tr.terminal_rsp_data.send_ussd.device_id.src = DEVICE_ID_ME;
3004                 tr.terminal_rsp_data.send_ussd.device_id.dest = DEVICE_ID_SIM;
3005                 tr.terminal_rsp_data.send_ussd.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
3006         } break;
3007         case SAT_PROATV_CMD_SETUP_CALL: {
3008                 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));
3009                 tr.terminal_rsp_data.setup_call.device_id.src = DEVICE_ID_ME;
3010                 tr.terminal_rsp_data.setup_call.device_id.dest = DEVICE_ID_SIM;
3011                 tr.terminal_rsp_data.setup_call.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
3012         } break;
3013         case SAT_PROATV_CMD_SETUP_IDLE_MODE_TEXT: {
3014                 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));
3015                 tr.terminal_rsp_data.setup_idle_mode_text.device_id.src = DEVICE_ID_ME;
3016                 tr.terminal_rsp_data.setup_idle_mode_text.device_id.dest = DEVICE_ID_SIM;
3017                 tr.terminal_rsp_data.setup_idle_mode_text.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
3018         } break;
3019         case SAT_PROATV_CMD_OPEN_CHANNEL: {
3020                 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));
3021                 tr.terminal_rsp_data.open_channel.device_id.src = DEVICE_ID_ME;
3022                 tr.terminal_rsp_data.open_channel.device_id.dest = DEVICE_ID_SIM;
3023                 tr.terminal_rsp_data.open_channel.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
3024         } break;
3025         case SAT_PROATV_CMD_LAUNCH_BROWSER: {
3026                 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));
3027                 tr.terminal_rsp_data.launch_browser.device_id.src = DEVICE_ID_ME;
3028                 tr.terminal_rsp_data.launch_browser.device_id.dest = DEVICE_ID_SIM;
3029                 tr.terminal_rsp_data.launch_browser.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
3030         } break;
3031         default:
3032                 dbg("unsupported command.");
3033                 break;
3034         }
3035
3036         rv = sat_manager_send_terminal_response(ctx->comm, plg, &tr);
3037         if (rv != TCORE_RETURN_SUCCESS)
3038                 return FALSE;
3039
3040         return TRUE;
3041 }
3042
3043 static gboolean _sat_manager_handle_setup_menu_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
3044 {
3045         TReturn rv = TCORE_RETURN_FAILURE;
3046         gboolean result = FALSE;
3047
3048         gint resp;
3049         struct treq_sat_terminal_rsp_data *tr;
3050         struct sat_manager_queue_data q_data;
3051
3052         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
3053
3054         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
3055                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
3056                 return result;
3057         }
3058
3059         if (!exec_result) {
3060                 dbg("[SAT] setup menu result data is null");
3061                 return result;
3062         }
3063
3064         if (!plg) {
3065                 dbg("there is no valid plugin at this point");
3066                 return result;
3067         }
3068
3069         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
3070         g_variant_get(exec_result, "(i)", &resp);
3071
3072         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
3073         if (!tr)
3074                 return result;
3075
3076         tr->cmd_number = q_data.cmd_data.setupMenuInd.command_detail.cmd_num;
3077         tr->cmd_type = q_data.cmd_data.setupMenuInd.command_detail.cmd_type;
3078
3079         memcpy((void*)&tr->terminal_rsp_data.setup_menu.command_detail,
3080                 &q_data.cmd_data.setupMenuInd.command_detail, sizeof(struct tel_sat_cmd_detail_info));
3081
3082         tr->terminal_rsp_data.setup_menu.device_id.src = q_data.cmd_data.setupMenuInd.device_id.dest;
3083         tr->terminal_rsp_data.setup_menu.device_id.dest = q_data.cmd_data.setupMenuInd.device_id.src;
3084
3085         dbg("[SAT] resp(%d)", resp);
3086
3087         switch (resp) {
3088         case RESULT_SUCCESS:
3089                 tr->terminal_rsp_data.setup_menu.result_type = RESULT_SUCCESS;
3090
3091                 if (q_data.cmd_data.setupMenuInd.text_attribute.b_txt_attr || q_data.cmd_data.setupMenuInd.text_attribute_list.list_cnt > 0)
3092                         tr->terminal_rsp_data.setup_menu.result_type = RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION;
3093
3094                 if (q_data.cmd_data.setupMenuInd.icon_id.is_exist)
3095                         tr->terminal_rsp_data.setup_menu.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
3096
3097                 tr->terminal_rsp_data.setup_menu.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3098                 break;
3099
3100         case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
3101                 tr->terminal_rsp_data.setup_menu.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
3102                 tr->terminal_rsp_data.setup_menu.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3103                 break;
3104
3105         default:
3106                 /* check the default case */
3107                 tr->terminal_rsp_data.setup_menu.result_type = resp;
3108                 tr->terminal_rsp_data.setup_menu.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3109                 dbg("[SAT] wrong result from app exec resp(%d)", resp);
3110                 break;
3111         }
3112
3113         result = TRUE;
3114         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
3115         if (rv != TCORE_RETURN_SUCCESS) {
3116                 dbg("fail to send terminal response");
3117                 result = FALSE;
3118         }
3119
3120         g_free(tr);
3121
3122         return result;
3123 }
3124
3125 static gboolean _sat_manager_handle_display_text_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
3126 {
3127         TReturn rv = TCORE_RETURN_FAILURE;
3128         gboolean result = FALSE;
3129
3130         gint resp, me_problem;
3131         struct treq_sat_terminal_rsp_data *tr;
3132         struct sat_manager_queue_data q_data;
3133
3134         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
3135
3136         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
3137                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
3138                 return result;
3139         }
3140
3141         if (!exec_result) {
3142                 dbg("[SAT] display text result data is null");
3143                 return result;
3144         }
3145
3146         if (!plg) {
3147                 dbg("there is no valid plugin at this point");
3148                 return result;
3149         }
3150
3151         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
3152         g_variant_get(exec_result, "(ii)", &resp, &me_problem);
3153
3154         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
3155         if (!tr)
3156                 return result;
3157
3158         tr->cmd_number = q_data.cmd_data.displayTextInd.command_detail.cmd_num;
3159         tr->cmd_type = q_data.cmd_data.displayTextInd.command_detail.cmd_type;
3160         memcpy((void*)&tr->terminal_rsp_data.display_text.command_detail, &q_data.cmd_data.displayTextInd.command_detail, sizeof(struct tel_sat_cmd_detail_info));
3161         tr->terminal_rsp_data.display_text.device_id.src = DEVICE_ID_ME;
3162         tr->terminal_rsp_data.display_text.device_id.dest = DEVICE_ID_SIM;
3163
3164         switch (resp) {
3165         case RESULT_SUCCESS:
3166                 tr->terminal_rsp_data.display_text.result_type = RESULT_SUCCESS;
3167
3168                 if (q_data.cmd_data.displayTextInd.text_attribute.b_txt_attr)
3169                         tr->terminal_rsp_data.display_text.result_type = RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION;
3170
3171                 if (q_data.cmd_data.displayTextInd.icon_id.is_exist)
3172                         tr->terminal_rsp_data.display_text.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
3173
3174                 tr->terminal_rsp_data.display_text.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3175                 break;
3176
3177         case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
3178                 tr->terminal_rsp_data.display_text.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
3179                 tr->terminal_rsp_data.display_text.me_problem_type = me_problem;
3180                 break;
3181
3182         default:
3183                 tr->terminal_rsp_data.display_text.result_type = resp;
3184                 tr->terminal_rsp_data.display_text.me_problem_type = me_problem;
3185                 dbg("[SAT] wrong result from app exec resp(%d) me_problem(%d)", resp, me_problem);
3186                 break;
3187         }
3188
3189         result = TRUE;
3190         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
3191         if (rv != TCORE_RETURN_SUCCESS) {
3192                 dbg("fail to send terminal response");
3193                 result = FALSE;
3194         }
3195
3196         g_free(tr);
3197
3198         return result;
3199 }
3200
3201 static gboolean _sat_manager_handle_play_tone_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
3202 {
3203         TReturn rv = TCORE_RETURN_FAILURE;
3204         gboolean result = FALSE;
3205
3206         gint resp;
3207         struct treq_sat_terminal_rsp_data *tr;
3208         struct sat_manager_queue_data q_data;
3209
3210         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
3211
3212         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
3213                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
3214                 return result;
3215         }
3216
3217         if (!exec_result) {
3218                 dbg("[SAT] display text result data is null");
3219                 return result;
3220         }
3221
3222         if (!plg) {
3223                 dbg("there is no valid plugin at this point");
3224                 return result;
3225         }
3226
3227         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
3228         g_variant_get(exec_result, "(i)", &resp);
3229
3230         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
3231         if (!tr)
3232                 return result;
3233
3234         tr->cmd_number = q_data.cmd_data.play_tone.command_detail.cmd_num;
3235         tr->cmd_type = q_data.cmd_data.play_tone.command_detail.cmd_type;
3236         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));
3237         tr->terminal_rsp_data.play_tone.device_id.src = DEVICE_ID_ME;
3238         tr->terminal_rsp_data.play_tone.device_id.dest = DEVICE_ID_SIM;
3239
3240         switch (resp) {
3241         case RESULT_SUCCESS:
3242                 tr->terminal_rsp_data.play_tone.result_type = RESULT_SUCCESS;
3243
3244                 if (q_data.cmd_data.play_tone.text_attribute.b_txt_attr)
3245                         tr->terminal_rsp_data.play_tone.result_type = RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION;
3246
3247                 if (q_data.cmd_data.play_tone.icon_id.is_exist)
3248                         tr->terminal_rsp_data.play_tone.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
3249
3250                 tr->terminal_rsp_data.play_tone.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3251                 break;
3252
3253         case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
3254                 tr->terminal_rsp_data.play_tone.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
3255                 tr->terminal_rsp_data.play_tone.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3256                 break;
3257
3258         case RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER:
3259                 tr->terminal_rsp_data.play_tone.result_type = RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER;
3260                 tr->terminal_rsp_data.play_tone.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3261                 break;
3262
3263         default:
3264                 tr->terminal_rsp_data.play_tone.result_type = resp;
3265                 tr->terminal_rsp_data.play_tone.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3266                 dbg("[SAT] wrong result from app exec resp(%d)", resp);
3267                 break;
3268         }
3269
3270         result = TRUE;
3271         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
3272         if (rv != TCORE_RETURN_SUCCESS) {
3273                 dbg("fail to send terminal response");
3274                 result = FALSE;
3275         }
3276
3277         g_free(tr);
3278         return result;
3279 }
3280
3281 static gboolean _sat_manager_handle_send_sms_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
3282 {
3283         TReturn rv = TCORE_RETURN_FAILURE;
3284         gboolean result = FALSE;
3285
3286         gint resp;
3287         struct treq_sat_terminal_rsp_data *tr;
3288         struct sat_manager_queue_data q_data;
3289
3290         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
3291
3292         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
3293                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
3294                 return result;
3295         }
3296
3297         if (!exec_result) {
3298                 dbg("[SAT] send sms data is null");
3299                 return result;
3300         }
3301
3302         if (!plg) {
3303                 dbg("there is no valid plugin at this point");
3304                 return result;
3305         }
3306
3307         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
3308         g_variant_get(exec_result, "(i)", &resp);
3309
3310         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
3311         if (!tr)
3312                 return result;
3313
3314         tr->cmd_number = q_data.cmd_data.sendSMSInd.command_detail.cmd_num;
3315         tr->cmd_type = q_data.cmd_data.sendSMSInd.command_detail.cmd_type;
3316         memcpy((void*)&tr->terminal_rsp_data.send_sms.command_detail, &q_data.cmd_data.sendSMSInd.command_detail, sizeof(struct tel_sat_cmd_detail_info));
3317         tr->terminal_rsp_data.send_sms.device_id.src = DEVICE_ID_ME;
3318         tr->terminal_rsp_data.send_sms.device_id.dest = q_data.cmd_data.sendSMSInd.device_id.src;
3319
3320         switch (resp) {
3321         case RESULT_SUCCESS:
3322                 tr->terminal_rsp_data.send_sms.result_type = RESULT_SUCCESS;
3323                 if (q_data.cmd_data.sendSMSInd.icon_id.is_exist)
3324                         tr->terminal_rsp_data.send_sms.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
3325
3326                 break;
3327
3328         case RESULT_INTRCTN_WITH_CC_OR_SMS_CTRL_PRMNT_PRBLM:
3329                 tr->terminal_rsp_data.send_sms.result_type = RESULT_INTRCTN_WITH_CC_OR_SMS_CTRL_PRMNT_PRBLM;
3330                 tr->terminal_rsp_data.send_sms.cc_problem_type = CC_PROBLEM_ACTION_NOT_ALLOWED;
3331                 break;
3332
3333         case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
3334                 tr->terminal_rsp_data.send_sms.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
3335                 tr->terminal_rsp_data.send_sms.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3336                 break;
3337
3338         case RESULT_BEYOND_ME_CAPABILITIES:
3339                 tr->terminal_rsp_data.send_sms.result_type = RESULT_BEYOND_ME_CAPABILITIES;
3340                 tr->terminal_rsp_data.send_sms.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3341                 break;
3342
3343         case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
3344                 tr->terminal_rsp_data.send_sms.result_type = RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME;
3345                 tr->terminal_rsp_data.send_sms.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3346                 break;
3347
3348         case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
3349                 tr->terminal_rsp_data.send_sms.result_type = RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME;
3350                 tr->terminal_rsp_data.send_sms.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3351                 break;
3352
3353         case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
3354                 tr->terminal_rsp_data.send_sms.result_type = RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING;
3355                 tr->terminal_rsp_data.send_sms.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3356                 break;
3357
3358         case RESULT_SMS_RP_ERROR:
3359                 tr->terminal_rsp_data.send_sms.result_type = RESULT_SMS_RP_ERROR;
3360                 tr->terminal_rsp_data.send_sms.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3361                 break;
3362
3363         case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
3364                 tr->terminal_rsp_data.send_sms.result_type = RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND;
3365                 tr->terminal_rsp_data.send_sms.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3366                 break;
3367
3368         default:
3369                 tr->terminal_rsp_data.send_sms.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
3370                 tr->terminal_rsp_data.send_sms.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3371                 break;
3372         }
3373
3374         result = TRUE;
3375         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
3376         if (rv != TCORE_RETURN_SUCCESS) {
3377                 dbg("fail to send terminal response");
3378                 result = FALSE;
3379         }
3380
3381         g_free(tr);
3382         return result;
3383 }
3384
3385 static gboolean _sat_manager_handle_send_ss_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
3386 {
3387         TReturn rv = TCORE_RETURN_FAILURE;
3388         gboolean result = FALSE;
3389
3390         gint resp, me_problem, ss_cause, call_ctrl_problem, ss_str_len;
3391         GVariant *ss_str = NULL;
3392         struct treq_sat_terminal_rsp_data *tr;
3393         struct sat_manager_queue_data q_data;
3394         /* call ctrl action, result data object, text */
3395
3396         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
3397
3398         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
3399                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
3400                 return result;
3401         }
3402
3403         if (!exec_result) {
3404                 dbg("[SAT] send ss data is null");
3405                 return result;
3406         }
3407
3408         if (!plg) {
3409                 dbg("there is no valid plugin at this point");
3410                 return result;
3411         }
3412
3413         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
3414         g_variant_get(exec_result, "(iii@vii)", &resp, &me_problem, &ss_cause, &ss_str, &ss_str_len, &call_ctrl_problem);
3415
3416         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
3417         if (!tr)
3418                 return result;
3419
3420         tr->cmd_number = q_data.cmd_data.send_ss.command_detail.cmd_num;
3421         tr->cmd_type = q_data.cmd_data.send_ss.command_detail.cmd_type;
3422         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));
3423         tr->terminal_rsp_data.send_ss.device_id.src = DEVICE_ID_ME;
3424         tr->terminal_rsp_data.send_ss.device_id.dest = q_data.cmd_data.send_ss.device_id.src;
3425
3426         switch (resp) {
3427         case RESULT_SUCCESS:
3428                 tr->terminal_rsp_data.send_ss.result_type = RESULT_SUCCESS;
3429                 if (q_data.cmd_data.send_ss.icon_id.is_exist)
3430                         tr->terminal_rsp_data.send_ss.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
3431
3432                 if (ss_str_len > 0 && ss_str) {
3433                         int local_index = 0, i = 0;
3434                         guchar data;
3435                         GVariantIter *iter = NULL;
3436                         GVariant *intermediate = NULL;
3437
3438                         intermediate = g_variant_get_variant(ss_str);
3439                         dbg("ss string format(%s)", g_variant_get_type_string(intermediate));
3440
3441                         g_variant_get(intermediate, "ay", &iter);
3442                         while (g_variant_iter_loop(iter, "y", &data)) {
3443                                 dbg("index(%d) data(%c) hex(0x%x)", local_index, data, data);
3444                                 tr->terminal_rsp_data.send_ss.text.string[local_index] = data;
3445                                 local_index++;
3446                         }
3447                         g_variant_iter_free(iter);
3448                         g_variant_unref(intermediate);
3449                         tr->terminal_rsp_data.send_ss.text.string_length = local_index;
3450 #if 0
3451                         char *tmp = NULL;
3452                         tmp = _convert_hex_string_to_bytes(tr->terminal_rsp_data.send_ss.text.string);
3453                         memset(tr->terminal_rsp_data.send_ss.text.string, 0x00,
3454                                 sizeof(tr->terminal_rsp_data.send_ss.text.string));
3455                         if (tmp) {
3456                                 memcpy(tr->terminal_rsp_data.send_ss.text.string, tmp,
3457                                         tr->terminal_rsp_data.send_ss.text.string_length);
3458                                 g_free(tmp);
3459                         } else {
3460                                 err("memcpy failed");
3461                         }
3462 #else
3463                         tr->terminal_rsp_data.send_ss.text.string_length = local_index;
3464                         if (tr->terminal_rsp_data.send_ss.text.string_length > 0) {
3465                                         int tmp_len;
3466                                         unsigned int dest_len;
3467                                         char tmp_str[SAT_TEXT_STRING_LEN_MAX + 1];
3468                                         char  *packed_data;
3469
3470                                         dbg("UTF 8 to GSM SMS default");
3471                                         tcore_util_convert_utf8_to_gsm((unsigned char*)tmp_str, &tmp_len,
3472                                                 (unsigned char*)tr->terminal_rsp_data.send_ss.text.string,
3473                                                 tr->terminal_rsp_data.send_ss.text.string_length);
3474                                         packed_data = (char*) tcore_util_pack_gsm7bit_ex((const unsigned char *)tmp_str, tmp_len, &dest_len);
3475                                         memset(tr->terminal_rsp_data.send_ss.text.string, 0x00,
3476                                                 sizeof(tr->terminal_rsp_data.send_ss.text.string));
3477                                         if (packed_data) {
3478                                                 memcpy((void*)tr->terminal_rsp_data.send_ss.text.string, packed_data, dest_len);
3479                                                 tr->terminal_rsp_data.send_ss.text.string_length = dest_len;
3480                                                 g_free(packed_data);
3481                                         }
3482                                 }
3483 #endif
3484                         for (i = 0; i < tr->terminal_rsp_data.send_ss.text.string_length; i++)
3485                                 dbg("string :[%c] [0x%x]", tr->terminal_rsp_data.send_ss.text.string[i], tr->terminal_rsp_data.send_ss.text.string[i]);
3486                         dbg("SS string len:%d", tr->terminal_rsp_data.send_ss.text.string_length);
3487                 }
3488                 break;
3489
3490         case RESULT_SS_RETURN_ERROR:
3491                 tr->terminal_rsp_data.send_ss.result_type = RESULT_SS_RETURN_ERROR;
3492                 if (ss_cause == SATK_SS_PROBLEM_FACILITY_NOT_SUPPORTED)
3493                         tr->terminal_rsp_data.send_ss.ss_problem = SATK_SS_PROBLEM_FACILITY_NOT_SUPPORTED;
3494                 else
3495                         tr->terminal_rsp_data.send_ss.ss_problem = SATK_SS_PROBLEM_NO_SPECIFIC_CAUSE;
3496                 break;
3497
3498         case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
3499                 tr->terminal_rsp_data.send_ss.result_type = RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND;
3500                 tr->terminal_rsp_data.send_ss.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3501                 break;
3502
3503         default:
3504                 tr->terminal_rsp_data.send_ss.result_type = RESULT_SS_RETURN_ERROR;
3505                 tr->terminal_rsp_data.send_ss.ss_problem = SATK_SS_PROBLEM_NO_SPECIFIC_CAUSE;
3506                 break;
3507         }
3508
3509         result = TRUE;
3510         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
3511         if (rv != TCORE_RETURN_SUCCESS) {
3512                 dbg("fail to send terminal response");
3513                 result = FALSE;
3514         }
3515         g_free(tr);
3516
3517 #if defined(TIZEN_PLATFORM_USE_QCOM_QMI)
3518         if (q_data.cmd_data.send_ss.alpha_id.alpha_data_len && q_data.cmd_data.send_ss.alpha_id.is_exist) {
3519                 char *path;
3520                 const gchar *cp_name;
3521                 TelephonySAT *sat;
3522                 TelephonyObjectSkeleton *object;
3523
3524                 dbg("AlphaID is present, terminate SAT-UI.");
3525                 cp_name = tcore_server_get_cp_name_by_plugin(plg);
3526                 if (cp_name == NULL) {
3527                         err("CP name is NULL");
3528                         goto Exit;
3529                 }
3530
3531                 dbg("CP Name: [%s]", cp_name);
3532                 path = g_strdup_printf("%s/%s", MY_DBUS_PATH, cp_name);
3533
3534                 /* Look-up Hash table for Object */
3535                 object = g_hash_table_lookup(ctx->objects, path);
3536                 dbg("Path: [%s] Interface object: [%p]", path, object);
3537                 g_free(path);
3538                 if (object == NULL) {
3539                         err("Object is NOT defined!!!");
3540                         goto Exit;
3541                 }
3542
3543                 sat = telephony_object_peek_sat(TELEPHONY_OBJECT(object));
3544                 telephony_sat_emit_end_proactive_session(sat, SAT_PROATV_CMD_TYPE_END_PROACTIVE_SESSION);
3545         }
3546 Exit:
3547 #endif
3548         return result;
3549 }
3550
3551 static gboolean _sat_manager_handle_send_ussd_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
3552 {
3553         TReturn rv = TCORE_RETURN_FAILURE;
3554         gboolean result = FALSE;
3555
3556         gint resp, me_problem, ss_cause, ussd_str_len;
3557         GVariant *ussd_str = NULL;
3558         struct treq_sat_terminal_rsp_data *tr;
3559         struct sat_manager_queue_data q_data;
3560         /* call ctrl action, result data object, text, result2, text2 */
3561
3562         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
3563
3564         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
3565                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
3566                 return result;
3567         }
3568
3569         if (!exec_result) {
3570                 dbg("[SAT] send ss data is null");
3571                 return result;
3572         }
3573
3574         if (!plg) {
3575                 dbg("there is no valid plugin at this point");
3576                 return result;
3577         }
3578
3579         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
3580         g_variant_get(exec_result, "(iii@vi)", &resp, &me_problem, &ss_cause, &ussd_str, &ussd_str_len);
3581
3582         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
3583         if (!tr)
3584                 return result;
3585
3586         tr->cmd_number = q_data.cmd_data.send_ussd.command_detail.cmd_num;
3587         tr->cmd_type = q_data.cmd_data.send_ussd.command_detail.cmd_type;
3588         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));
3589         tr->terminal_rsp_data.send_ussd.device_id.src = DEVICE_ID_ME;
3590         tr->terminal_rsp_data.send_ussd.device_id.dest = q_data.cmd_data.send_ussd.device_id.src;
3591
3592         switch (resp) {
3593         case RESULT_SUCCESS:
3594                 tr->terminal_rsp_data.send_ussd.result_type = RESULT_SUCCESS;
3595                 if (q_data.cmd_data.send_ussd.icon_id.is_exist)
3596                         tr->terminal_rsp_data.send_ussd.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
3597
3598                 if (ussd_str_len > 0 && ussd_str) {
3599                         int local_index = 0, i = 0;
3600                         guchar data;
3601                         GVariantIter *iter = NULL;
3602                         GVariant *intermediate = NULL;
3603                         enum alphabet_format alpha_format;
3604
3605                         intermediate = g_variant_get_variant(ussd_str);
3606                         dbg("ussd string format(%s)", g_variant_get_type_string(intermediate));
3607
3608                         g_variant_get(intermediate, "ay", &iter);
3609                         while (g_variant_iter_loop(iter, "y", &data)) {
3610                                 dbg("local_index(%d) data(%c)", local_index, data);
3611                                 tr->terminal_rsp_data.send_ussd.text.string[local_index] = data;
3612                                 local_index++;
3613                         }
3614
3615
3616                         tr->terminal_rsp_data.send_ussd.text.string_length = local_index;
3617                         tr->terminal_rsp_data.send_ussd.text.dcs.raw_dcs = q_data.cmd_data.send_ussd.ussd_string.dsc.raw_dcs;
3618                         /* bits 2 & 3 indicate the character set being used */
3619                         switch (tr->terminal_rsp_data.send_ussd.text.dcs.raw_dcs & 0x0C) {
3620                         case 0x00:
3621                         case 0x0C:
3622                                 alpha_format = ALPHABET_FORMAT_SMS_DEFAULT;
3623                                 break;
3624
3625                         case 0x04:
3626                                 alpha_format = ALPHABET_FORMAT_8BIT_DATA;
3627                                 break;
3628
3629                         case 0X08:
3630                                 alpha_format = ALPHABET_FORMAT_UCS2;
3631                                 break;
3632
3633                         default:
3634                                 alpha_format = ALPHABET_FORMAT_RESERVED;
3635                                 break;
3636                         }
3637                         dbg("string :[%s] len:[%d] dcs:[%d] alpha_format:[%d]",
3638                                 tr->terminal_rsp_data.send_ussd.text.string,
3639                                 tr->terminal_rsp_data.send_ussd.text.string_length,
3640                                 tr->terminal_rsp_data.send_ussd.text.dcs.raw_dcs, alpha_format);
3641                         g_variant_iter_free(iter);
3642                         g_variant_unref(intermediate);
3643                         switch (alpha_format) {
3644                         case ALPHABET_FORMAT_SMS_DEFAULT:
3645                                 /* As per the test spec TS 151.010-04 raw dcs for SMS default is 0 */
3646                                 tr->terminal_rsp_data.send_ussd.text.dcs.raw_dcs = ALPHABET_FORMAT_SMS_DEFAULT;
3647                                 if (tr->terminal_rsp_data.send_ussd.text.string_length > 0) {
3648                                         int tmp_len;
3649                                         char tmp_str[SAT_TEXT_STRING_LEN_MAX + 1];
3650                                         char  *packed_data;
3651
3652                                         dbg("UTF 8 to GSM SMS default");
3653                                         tcore_util_convert_utf8_to_gsm((unsigned char*)tmp_str, &tmp_len,
3654                                                 (unsigned char*)tr->terminal_rsp_data.send_ussd.text.string,
3655                                                 tr->terminal_rsp_data.send_ussd.text.string_length);
3656                                         packed_data = (char*) tcore_util_pack_gsm7bit((const unsigned char *)tmp_str, tmp_len);
3657                                         memset(tr->terminal_rsp_data.send_ussd.text.string, 0x00,
3658                                                 sizeof(tr->terminal_rsp_data.send_ussd.text.string));
3659                                         if (packed_data) {
3660                                                 memcpy((void*)tr->terminal_rsp_data.send_ussd.text.string, packed_data, strlen(packed_data));
3661                                                 tr->terminal_rsp_data.send_ussd.text.string_length = strlen(packed_data);
3662                                                 g_free(packed_data);
3663                                         }
3664                                 }
3665                                 dbg("final ussd len:%d", tr->terminal_rsp_data.send_ussd.text.string_length);
3666                                 for (i = 0; i < tr->terminal_rsp_data.send_ussd.text.string_length; i++)
3667                                         dbg("string :%c \n", tr->terminal_rsp_data.send_ussd.text.string[i]);
3668                                 break;
3669                         case ALPHABET_FORMAT_8BIT_DATA: {
3670                                 gint output_data_len = 0;
3671                                 gchar output_data[SAT_USSD_STRING_LEN_MAX];
3672                                 dbg("UTF 8 to GSM 8 BIT DATA");
3673                                 tcore_util_convert_utf8_to_gsm((unsigned char *)output_data, &output_data_len,
3674                                         (unsigned char *)tr->terminal_rsp_data.send_ussd.text.string,
3675                                         tr->terminal_rsp_data.send_ussd.text.string_length);
3676                                 memset(tr->terminal_rsp_data.send_ussd.text.string, 0x00,
3677                                         sizeof(tr->terminal_rsp_data.send_ussd.text.string));
3678                                 if (output_data_len > 0) {
3679                                         memcpy((void*)tr->terminal_rsp_data.send_ussd.text.string, output_data, output_data_len);
3680                                         tr->terminal_rsp_data.send_ussd.text.string_length = output_data_len;
3681                                 }
3682                                 dbg("final ussd len:%d", tr->terminal_rsp_data.send_ussd.text.string_length);
3683                                 for (i = 0; i < tr->terminal_rsp_data.send_ussd.text.string_length; i++)
3684                                         dbg("string :%c \n", tr->terminal_rsp_data.send_ussd.text.string[i]);
3685                                 }
3686                                 break;
3687                         case ALPHABET_FORMAT_UCS2: {
3688                                 char *tmp = NULL;
3689                                 int str_len = 0;
3690                                 dbg("UCS2 DATA");
3691                                 tcore_util_convert_utf8_to_ucs2(&tmp,
3692                                         &str_len, (unsigned char*)tr->terminal_rsp_data.send_ussd.text.string,
3693                                         tr->terminal_rsp_data.send_ussd.text.string_length);
3694                                 memset(tr->terminal_rsp_data.send_ussd.text.string, 0x00,
3695                                         sizeof(tr->terminal_rsp_data.send_ussd.text.string));
3696                                 memcpy(tr->terminal_rsp_data.send_ussd.text.string, tmp, str_len);
3697                                 tr->terminal_rsp_data.send_ussd.text.string_length = str_len;
3698                                 dbg("final ussd len:%d", tr->terminal_rsp_data.send_ussd.text.string_length);
3699                                 for (i = 0; i < tr->terminal_rsp_data.send_ussd.text.string_length; i++)
3700                                         dbg("string :%c \n", tr->terminal_rsp_data.send_ussd.text.string[i]);
3701                                 g_free(tmp);
3702                                 }
3703                                 break;
3704                         default:
3705                                 break;
3706                         }
3707                 }
3708                 break;
3709
3710         case RESULT_SS_RETURN_ERROR:
3711         case RESULT_USSD_RETURN_ERROR:
3712                 tr->terminal_rsp_data.send_ussd.result_type = RESULT_USSD_RETURN_ERROR;
3713                 if (ss_cause == SATK_USSD_PROBLEM_UNKNOWN_ALPHABET)
3714                         tr->terminal_rsp_data.send_ussd.ussd_problem = ss_cause;
3715                 break;
3716
3717         case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
3718                 tr->terminal_rsp_data.send_ussd.result_type = RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND;
3719                 tr->terminal_rsp_data.send_ussd.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3720                 break;
3721
3722         case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
3723                 tr->terminal_rsp_data.send_ussd.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
3724                 tr->terminal_rsp_data.send_ussd.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3725                 break;
3726
3727         default:
3728                 tr->terminal_rsp_data.send_ussd.result_type = RESULT_USSD_RETURN_ERROR;
3729                 tr->terminal_rsp_data.send_ussd.ussd_problem = SATK_USSD_PROBLEM_NO_SPECIFIC_CAUSE;
3730                 break;
3731         }
3732
3733         result = TRUE;
3734         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
3735         if (rv != TCORE_RETURN_SUCCESS) {
3736                 dbg("fail to send terminal response");
3737                 result = FALSE;
3738         }
3739         g_free(tr);
3740
3741 #if defined(TIZEN_PLATFORM_USE_QCOM_QMI)
3742         if (q_data.cmd_data.send_ussd.alpha_id.alpha_data_len && q_data.cmd_data.send_ussd.alpha_id.is_exist) {
3743                 char *path;
3744                 const gchar *cp_name;
3745                 TelephonySAT *sat;
3746                 TelephonyObjectSkeleton *object;
3747
3748                 dbg("AlphaID is present, terminate SAT-UI.");
3749                 /* emit session end signal */
3750                 cp_name = tcore_server_get_cp_name_by_plugin(plg);
3751                 if (cp_name == NULL) {
3752                         err("CP name is NULL");
3753                         goto Exit;
3754                 }
3755
3756                 dbg("CP Name: [%s]", cp_name);
3757                 path = g_strdup_printf("%s/%s", MY_DBUS_PATH, cp_name);
3758
3759                 /* Look-up Hash table for Object */
3760                 object = g_hash_table_lookup(ctx->objects, path);
3761                 dbg("Path: [%s] Interface object: [%p]", path, object);
3762                 g_free(path);
3763                 if (object == NULL) {
3764                         err("Object is NOT defined!!!");
3765                         goto Exit;
3766                 }
3767
3768                 sat = telephony_object_peek_sat(TELEPHONY_OBJECT(object));
3769                 telephony_sat_emit_end_proactive_session(sat, SAT_PROATV_CMD_TYPE_END_PROACTIVE_SESSION);
3770         }
3771
3772 Exit:
3773 #endif
3774         return result;
3775 }
3776
3777 static gboolean _sat_manager_handle_setup_call_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
3778 {
3779         TReturn rv = TCORE_RETURN_FAILURE;
3780         gboolean result = FALSE;
3781
3782         gint resp, me_problem, cc_problem, call_cause;
3783         struct treq_sat_terminal_rsp_data *tr;
3784         struct sat_manager_queue_data q_data;
3785
3786         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
3787
3788         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
3789                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
3790                 return result;
3791         }
3792
3793         if (!exec_result) {
3794                 dbg("[SAT] setup call data is null");
3795                 return result;
3796         }
3797
3798         if (!plg) {
3799                 dbg("there is no valid plugin at this point");
3800                 return result;
3801         }
3802
3803         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
3804         g_variant_get(exec_result, "(iiii)", &resp, &me_problem, &cc_problem, &call_cause);
3805
3806         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
3807         if (!tr)
3808                 return result;
3809
3810         tr->cmd_number = q_data.cmd_data.setup_call.command_detail.cmd_num;
3811         tr->cmd_type = q_data.cmd_data.setup_call.command_detail.cmd_type;
3812         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));
3813         tr->terminal_rsp_data.setup_call.device_id.src = DEVICE_ID_ME;
3814         tr->terminal_rsp_data.setup_call.device_id.dest = q_data.cmd_data.setup_call.device_id.src;
3815
3816         switch (resp) {
3817         case RESULT_SUCCESS:
3818                 tr->terminal_rsp_data.setup_call.result_type = RESULT_SUCCESS;
3819                 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)
3820                         tr->terminal_rsp_data.setup_call.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
3821                 tr->terminal_rsp_data.setup_call.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3822                 tr->terminal_rsp_data.setup_call.cc_problem_type = CC_PROBLEM_NO_SPECIFIC_CAUSE;
3823                 break;
3824
3825         case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
3826                 tr->terminal_rsp_data.setup_call.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
3827                 tr->terminal_rsp_data.setup_call.me_problem_type = me_problem;
3828                 break;
3829
3830         case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND: {
3831                 tr->terminal_rsp_data.setup_call.result_type = RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND;
3832                 switch (call_cause) {
3833                 case CALL_ERROR_BUSY:
3834                         tr->terminal_rsp_data.setup_call.network_problem_type = NETWORK_PROBLEM_USER_BUSY;
3835                         break;
3836                 default:
3837                         tr->terminal_rsp_data.setup_call.network_problem_type = NETWORK_PROBLEM_NO_SPECIFIC_CAUSE;
3838                         break;
3839                 }
3840         } break;
3841
3842         case RESULT_USER_CLEAR_DOWN_CALL_BEFORE_CONN:
3843                 tr->terminal_rsp_data.setup_call.result_type = RESULT_USER_CLEAR_DOWN_CALL_BEFORE_CONN;
3844                 tr->terminal_rsp_data.setup_call.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3845                 tr->terminal_rsp_data.setup_call.cc_problem_type = CC_PROBLEM_NO_SPECIFIC_CAUSE;
3846                 break;
3847
3848         case RESULT_BEYOND_ME_CAPABILITIES:
3849                 tr->terminal_rsp_data.setup_call.result_type = RESULT_BEYOND_ME_CAPABILITIES;
3850                 tr->terminal_rsp_data.setup_call.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3851                 tr->terminal_rsp_data.setup_call.cc_problem_type = CC_PROBLEM_NO_SPECIFIC_CAUSE;
3852                 break;
3853
3854         case RESULT_INTRCTN_WITH_CC_OR_SMS_CTRL_PRMNT_PRBLM:
3855                 tr->terminal_rsp_data.setup_call.result_type = RESULT_INTRCTN_WITH_CC_OR_SMS_CTRL_PRMNT_PRBLM;
3856                 tr->terminal_rsp_data.setup_call.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3857                 tr->terminal_rsp_data.setup_call.cc_problem_type = cc_problem;
3858                 break;
3859
3860         default:
3861                 break;
3862         }
3863
3864         /* TODO Other infomation set - not supported */
3865         tr->terminal_rsp_data.setup_call.other_info = FALSE;
3866
3867         result = TRUE;
3868         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
3869         if (rv != TCORE_RETURN_SUCCESS) {
3870                 dbg("fail to send terminal response");
3871                 result = FALSE;
3872         }
3873
3874         g_free(tr);
3875         return result;
3876 }
3877
3878 static gboolean _sat_manager_handle_setup_idle_mode_text_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
3879 {
3880         TReturn rv = TCORE_RETURN_FAILURE;
3881         gboolean result = FALSE;
3882
3883         gint resp;
3884         struct treq_sat_terminal_rsp_data tr;
3885         struct sat_manager_queue_data q_data;
3886
3887         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
3888         memset(&tr, 0, sizeof(struct treq_sat_terminal_rsp_data));
3889
3890         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
3891                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
3892                 return result;
3893         }
3894
3895         if (!exec_result) {
3896                 dbg("[SAT] send ss data is null");
3897                 return result;
3898         }
3899
3900         if (!plg) {
3901                 dbg("there is no valid plugin at this point");
3902                 return result;
3903         }
3904
3905         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
3906         g_variant_get(exec_result, "(i)", &resp);
3907
3908         tr.cmd_number = q_data.cmd_data.idle_mode.command_detail.cmd_num;
3909         tr.cmd_type = q_data.cmd_data.idle_mode.command_detail.cmd_type;
3910         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));
3911         tr.terminal_rsp_data.setup_idle_mode_text.device_id.src = q_data.cmd_data.idle_mode.device_id.dest;
3912         tr.terminal_rsp_data.setup_idle_mode_text.device_id.dest = q_data.cmd_data.idle_mode.device_id.src;
3913
3914         switch (resp) {
3915         case RESULT_SUCCESS:
3916                 tr.terminal_rsp_data.setup_idle_mode_text.result_type = RESULT_SUCCESS;
3917                 if (q_data.cmd_data.idle_mode.icon_id.is_exist) {
3918 #if defined(TIZEN_SUPPORT_SAT_ICON)
3919                         tr.terminal_rsp_data.setup_idle_mode_text.result_type = RESULT_SUCCESS;
3920 #else
3921                         tr.terminal_rsp_data.setup_idle_mode_text.result_type = RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME;
3922 #endif
3923                 }
3924
3925                 break;
3926         default:
3927                 tr.terminal_rsp_data.setup_idle_mode_text.result_type = resp;
3928                 break;
3929         }
3930
3931         result = TRUE;
3932         rv = sat_manager_send_terminal_response(ctx->comm, plg, &tr);
3933         if (rv != TCORE_RETURN_SUCCESS) {
3934                 dbg("fail to send terminal response");
3935                 result = FALSE;
3936         }
3937
3938         return result;
3939 }
3940
3941 static gboolean sat_manager_handle_open_channel_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
3942 {
3943         TReturn rv = TCORE_RETURN_FAILURE;
3944         gboolean result = FALSE;
3945
3946         gint resp, me_problem, bip_problem;
3947         gint bearer_type, channel_id, channel_status, channel_status_info, buffer_size;
3948         gboolean other_info;
3949         GVariant *desc_tmp, *bearer_desc;
3950
3951         struct treq_sat_terminal_rsp_data *tr;
3952         struct sat_manager_queue_data q_data;
3953
3954         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
3955
3956         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
3957                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
3958                 return result;
3959         }
3960
3961         if (!exec_result) {
3962                 dbg("[SAT] open channel data is null");
3963                 return result;
3964         }
3965
3966         if (!plg) {
3967                 dbg("there is no valid plugin at this point");
3968                 return result;
3969         }
3970
3971         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
3972         g_variant_get(exec_result, "(iiiiiiiibv)", &resp, &me_problem, &bip_problem,
3973                         &bearer_type, &channel_id, &channel_status, &channel_status_info, &buffer_size,
3974                         &other_info, &desc_tmp);
3975
3976         bearer_desc = g_variant_get_variant(desc_tmp);
3977
3978         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
3979         if (!tr)
3980                 return result;
3981
3982         tr->cmd_number = q_data.cmd_data.open_channel.command_detail.cmd_num;
3983         tr->cmd_type = q_data.cmd_data.open_channel.command_detail.cmd_type;
3984         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));
3985
3986         tr->terminal_rsp_data.open_channel.device_id.src = q_data.cmd_data.open_channel.device_id.dest;
3987         tr->terminal_rsp_data.open_channel.device_id.dest = q_data.cmd_data.open_channel.device_id.src;
3988
3989         tr->terminal_rsp_data.open_channel.result_type = resp;
3990         switch (resp) {
3991         case RESULT_SUCCESS:
3992         case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
3993         case RESULT_SUCCESS_WITH_MISSING_INFO:
3994                 /* channel status */
3995                 break;
3996
3997         case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
3998         case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
3999                 tr->terminal_rsp_data.open_channel.me_problem_type = me_problem;
4000                 break;
4001
4002         case RESULT_BEARER_INDEPENDENT_PROTOCOL_ERROR:
4003                 tr->terminal_rsp_data.open_channel.bip_problem_type = bip_problem;
4004                 break;
4005
4006         default:
4007                 break;
4008         }
4009
4010         tr->terminal_rsp_data.open_channel.channel_status.channel_id = channel_id;
4011         tr->terminal_rsp_data.open_channel.channel_status.status = channel_status;
4012         tr->terminal_rsp_data.open_channel.channel_status.status_info = channel_status_info;
4013
4014         dbg("check channel id(%d) channel status(%d) channel info(%d)", channel_id, channel_status, channel_status_info);
4015
4016         /* memcpy(tr->terminal_rsp_data.open_channel.buffer_size.size, &buffer_size, sizeof(unsigned char)*2); */
4017         tr->terminal_rsp_data.open_channel.buffer_size.size[0] = buffer_size >> 8;
4018         tr->terminal_rsp_data.open_channel.buffer_size.size[1] = buffer_size & 0xFF;
4019         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]);
4020
4021         tr->terminal_rsp_data.open_channel.bearer_desc.bearer_type = bearer_type;
4022         switch (bearer_type) {
4023         case BEARER_CSD: {
4024                 gint data_rate, service_type, conn_element_type;
4025
4026                 dbg("bearer_desc cs bearer type_format(%s)", g_variant_get_type_string(bearer_desc));
4027                 g_variant_get(bearer_desc, "(iii)", &data_rate, &service_type, &conn_element_type);
4028                 dbg("check cs bearer data_rade(%d), service_type(%d), conn_element_type(%d)", data_rate, service_type, conn_element_type);
4029
4030                 tr->terminal_rsp_data.open_channel.bearer_desc.bearer_parameter.cs_bearer_param.data_rate = data_rate;
4031                 tr->terminal_rsp_data.open_channel.bearer_desc.bearer_parameter.cs_bearer_param.service_type = service_type;
4032                 tr->terminal_rsp_data.open_channel.bearer_desc.bearer_parameter.cs_bearer_param.connection_element_type = conn_element_type;
4033         } break;
4034         case BEARER_GPRS: {
4035                 gint precedence_class, delay_class, reliability_class;
4036                 gint peak_class, mean_class, pdp_type;
4037
4038                 dbg("bearer_desc ps bearer type_format(%s)", g_variant_get_type_string(bearer_desc));
4039                 g_variant_get(bearer_desc, "(iiiiii)", &precedence_class, &delay_class, &reliability_class,
4040                         &peak_class, &mean_class, &pdp_type);
4041                 dbg("check ps bearer precedence class(%d), delay class(%d), reliability class(%d) peak class(%d) mean class(%d) pdp_type(%d)",
4042                         precedence_class, delay_class, reliability_class, peak_class, mean_class, pdp_type);
4043
4044                 tr->terminal_rsp_data.open_channel.bearer_desc.bearer_parameter.ps_bearer_param.precedence_class = precedence_class;
4045                 tr->terminal_rsp_data.open_channel.bearer_desc.bearer_parameter.ps_bearer_param.delay_class = delay_class;
4046                 tr->terminal_rsp_data.open_channel.bearer_desc.bearer_parameter.ps_bearer_param.reliability_class = reliability_class;
4047                 tr->terminal_rsp_data.open_channel.bearer_desc.bearer_parameter.ps_bearer_param.peak_throughput_class = peak_class;
4048                 tr->terminal_rsp_data.open_channel.bearer_desc.bearer_parameter.ps_bearer_param.mean_throughput_class = mean_class;
4049                 tr->terminal_rsp_data.open_channel.bearer_desc.bearer_parameter.ps_bearer_param.pdp_type = pdp_type;
4050                 } break;
4051         case BEARER_LOCAL_LINK_TECHNOLOGY_INDEPENDENT: {
4052                 gint service_type;
4053                 gchar *service_record = NULL;
4054
4055                 dbg("bearer_desc link local type_format(%s)", g_variant_get_type_string(bearer_desc));
4056                 g_variant_get(bearer_desc, "(is)", &service_type, &service_record);
4057                 dbg("check link local service_type(%d), service_record(%d)", service_type, service_record);
4058
4059                 tr->terminal_rsp_data.open_channel.bearer_desc.bearer_parameter.local_link_bearer_param.service_type = service_type;
4060
4061                 if (service_record) {
4062                         memcpy(tr->terminal_rsp_data.open_channel.bearer_desc.bearer_parameter.local_link_bearer_param.service_record, service_record, strlen(service_record));
4063                         g_free(service_record);
4064                 }
4065         } break;
4066         default:
4067         break;
4068         }
4069
4070         result = TRUE;
4071         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
4072         if (rv != TCORE_RETURN_SUCCESS) {
4073                 dbg("fail to send terminal response");
4074                 result = FALSE;
4075         }
4076
4077         g_free(tr);
4078         return result;
4079 }
4080
4081 static gboolean sat_manager_handle_close_channel_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
4082 {
4083         TReturn rv = TCORE_RETURN_FAILURE;
4084         gboolean result = FALSE;
4085
4086         gint resp, me_problem, bip_problem;
4087
4088         struct treq_sat_terminal_rsp_data *tr;
4089         struct sat_manager_queue_data q_data;
4090
4091         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
4092
4093         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
4094                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
4095                 return result;
4096         }
4097
4098         if (!exec_result) {
4099                 dbg("[SAT] close channel data is null");
4100                 return result;
4101         }
4102
4103         if (!plg) {
4104                 dbg("there is no valid plugin at this point");
4105                 return result;
4106         }
4107
4108         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
4109         g_variant_get(exec_result, "(iii)", &resp, &me_problem, &bip_problem);
4110
4111         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
4112         if (!tr)
4113                 return result;
4114
4115         tr->cmd_number = q_data.cmd_data.close_channel.command_detail.cmd_num;
4116         tr->cmd_type = q_data.cmd_data.close_channel.command_detail.cmd_type;
4117         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));
4118
4119         tr->terminal_rsp_data.close_channel.device_id.src = DEVICE_ID_ME;
4120         tr->terminal_rsp_data.close_channel.device_id.dest = q_data.cmd_data.close_channel.device_id.src;
4121
4122         tr->terminal_rsp_data.close_channel.result_type = resp;
4123         switch (resp) {
4124         case RESULT_SUCCESS:
4125         case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
4126         case RESULT_SUCCESS_WITH_MISSING_INFO:
4127                 /* channel status */
4128                 break;
4129
4130         case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
4131         case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
4132                 tr->terminal_rsp_data.close_channel.me_problem_type = me_problem;
4133                 break;
4134
4135         case RESULT_BEARER_INDEPENDENT_PROTOCOL_ERROR:
4136                 tr->terminal_rsp_data.close_channel.bip_problem_type = bip_problem;
4137                 break;
4138
4139         default:
4140                 break;
4141         }
4142
4143         result = TRUE;
4144         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
4145         if (rv != TCORE_RETURN_SUCCESS) {
4146                 dbg("fail to send terminal response");
4147                 result = FALSE;
4148         }
4149
4150         g_free(tr);
4151         return result;
4152 }
4153
4154 static gboolean sat_manager_handle_receive_data_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
4155 {
4156         TReturn rv = TCORE_RETURN_FAILURE;
4157         gboolean result = FALSE;
4158
4159         gint resp, me_problem, bip_problem;
4160         gint data_str_len, data_len;
4161         gboolean other_info;
4162         GVariant *received_data;
4163
4164         struct treq_sat_terminal_rsp_data *tr;
4165         struct sat_manager_queue_data q_data;
4166
4167         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
4168
4169         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
4170                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
4171                 return result;
4172         }
4173
4174         if (!exec_result) {
4175                 dbg("[SAT] receive data data is null");
4176                 return result;
4177         }
4178
4179         if (!plg) {
4180                 dbg("there is no valid plugin at this point");
4181                 return result;
4182         }
4183
4184         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
4185         g_variant_get(exec_result, "(iiiiibv)", &resp, &me_problem, &bip_problem, &data_str_len, &data_len, &other_info, &received_data);
4186
4187         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
4188         if (!tr)
4189                 return result;
4190
4191         tr->cmd_number = q_data.cmd_data.receive_data.command_detail.cmd_num;
4192         tr->cmd_type = q_data.cmd_data.receive_data.command_detail.cmd_type;
4193         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));
4194
4195         tr->terminal_rsp_data.receive_data.device_id.src = DEVICE_ID_ME;
4196         tr->terminal_rsp_data.receive_data.device_id.dest = q_data.cmd_data.receive_data.device_id.src;
4197
4198         tr->terminal_rsp_data.receive_data.result_type = resp;
4199         switch (resp) {
4200         case RESULT_SUCCESS:
4201         case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
4202         case RESULT_SUCCESS_WITH_MISSING_INFO:
4203                 /* channel status */
4204                 break;
4205
4206         case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
4207         case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
4208                 tr->terminal_rsp_data.receive_data.me_problem_type = me_problem;
4209                 break;
4210
4211         case RESULT_BEARER_INDEPENDENT_PROTOCOL_ERROR:
4212                 tr->terminal_rsp_data.receive_data.bip_problem_type = bip_problem;
4213                 break;
4214
4215         default:
4216                 break;
4217         }
4218
4219         tr->terminal_rsp_data.receive_data.channel_data_len.data_len = data_len;
4220         tr->terminal_rsp_data.receive_data.channel_data.data_string_len = data_str_len;
4221
4222         if (received_data) {
4223                 int local_index = 0;
4224                 guchar data;
4225                 GVariantIter *iter = NULL;
4226
4227                 dbg("additional data exist type_format(%s)", g_variant_get_type_string(received_data));
4228
4229                 g_variant_get(received_data, "ay", &iter);
4230                 while (g_variant_iter_loop(iter, "y", &data)) {
4231                         tr->terminal_rsp_data.receive_data.channel_data.data_string[local_index] = data;
4232                         local_index++;
4233                 }
4234                 g_variant_iter_free(iter);
4235
4236                 dbg("the last index data(%d), data_total_len(%d)", local_index, data_str_len);
4237         }
4238
4239         result = TRUE;
4240         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
4241         if (rv != TCORE_RETURN_SUCCESS) {
4242                 dbg("fail to send terminal response");
4243                 result = FALSE;
4244         }
4245
4246         g_free(tr);
4247         return result;
4248 }
4249
4250 static gboolean sat_manager_handle_send_data_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
4251 {
4252         TReturn rv = TCORE_RETURN_FAILURE;
4253         gboolean result = FALSE;
4254
4255         gint resp, me_problem, bip_problem;
4256         gint data_len;
4257
4258         struct treq_sat_terminal_rsp_data *tr;
4259         struct sat_manager_queue_data q_data;
4260
4261         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
4262
4263         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
4264                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
4265                 return result;
4266         }
4267
4268         if (!exec_result) {
4269                 dbg("[SAT] send data data is null");
4270                 return result;
4271         }
4272
4273         if (!plg) {
4274                 dbg("there is no valid plugin at this point");
4275                 return result;
4276         }
4277
4278         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
4279         g_variant_get(exec_result, "(iiii)", &resp, &me_problem, &bip_problem, &data_len);
4280
4281         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
4282         if (!tr)
4283                 return result;
4284
4285         tr->cmd_number = q_data.cmd_data.send_data.command_detail.cmd_num;
4286         tr->cmd_type = q_data.cmd_data.send_data.command_detail.cmd_type;
4287         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));
4288
4289         tr->terminal_rsp_data.send_data.device_id.src = DEVICE_ID_ME;
4290         tr->terminal_rsp_data.send_data.device_id.dest = q_data.cmd_data.send_data.device_id.src;
4291
4292         tr->terminal_rsp_data.send_data.result_type = resp;
4293         switch (resp) {
4294         case RESULT_SUCCESS:
4295         case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
4296         case RESULT_SUCCESS_WITH_MISSING_INFO:
4297                 /* channel status */
4298                 break;
4299
4300         case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
4301         case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
4302                 tr->terminal_rsp_data.send_data.me_problem_type = me_problem;
4303                 break;
4304
4305         case RESULT_BEARER_INDEPENDENT_PROTOCOL_ERROR:
4306                 tr->terminal_rsp_data.send_data.bip_problem_type = bip_problem;
4307                 break;
4308
4309         default:
4310                 break;
4311         }
4312
4313         tr->terminal_rsp_data.send_data.channel_data_len.data_len = data_len;
4314
4315         result = TRUE;
4316         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
4317         if (rv != TCORE_RETURN_SUCCESS) {
4318                 dbg("fail to send terminal response");
4319                 result = FALSE;
4320         }
4321
4322         g_free(tr);
4323         return result;
4324 }
4325
4326 static gboolean sat_manager_handle_get_channel_status_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
4327 {
4328         TReturn rv = TCORE_RETURN_FAILURE;
4329         gboolean result = FALSE;
4330
4331         gint resp, me_problem, bip_problem;
4332         gint channel_id, channel_status, channel_status_info;
4333
4334         struct treq_sat_terminal_rsp_data *tr;
4335         struct sat_manager_queue_data q_data;
4336
4337         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
4338
4339         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
4340                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
4341                 return result;
4342         }
4343
4344         if (!exec_result) {
4345                 dbg("[SAT] get channel status data is null");
4346                 return result;
4347         }
4348
4349         if (!plg) {
4350                 dbg("there is no valid plugin at this point");
4351                 return result;
4352         }
4353
4354         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
4355         g_variant_get(exec_result, "(iiiiii)", &resp, &me_problem, &bip_problem,
4356                 &channel_id, &channel_status, &channel_status_info);
4357
4358         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
4359         if (!tr)
4360                 return result;
4361
4362         tr->cmd_number = q_data.cmd_data.get_channel_status.command_detail.cmd_num;
4363         tr->cmd_type = q_data.cmd_data.get_channel_status.command_detail.cmd_type;
4364         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));
4365
4366         tr->terminal_rsp_data.get_channel_status.device_id.src = q_data.cmd_data.get_channel_status.device_id.dest;
4367         tr->terminal_rsp_data.get_channel_status.device_id.dest = q_data.cmd_data.get_channel_status.device_id.src;
4368
4369         tr->terminal_rsp_data.get_channel_status.result_type = resp;
4370         switch (resp) {
4371         case RESULT_SUCCESS:
4372         case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
4373         case RESULT_SUCCESS_WITH_MISSING_INFO:
4374                 /* channel status */
4375                 break;
4376
4377         case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
4378         case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
4379                 tr->terminal_rsp_data.get_channel_status.me_problem_type = me_problem;
4380                 break;
4381
4382         case RESULT_BEARER_INDEPENDENT_PROTOCOL_ERROR:
4383                 tr->terminal_rsp_data.get_channel_status.bip_problem_type = bip_problem;
4384                 break;
4385
4386         default:
4387                 break;
4388         }
4389
4390         tr->terminal_rsp_data.get_channel_status.channel_status.channel_id = channel_id;
4391         tr->terminal_rsp_data.get_channel_status.channel_status.status = channel_status;
4392         tr->terminal_rsp_data.get_channel_status.channel_status.status_info = channel_status_info;
4393
4394         result = TRUE;
4395         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
4396         if (rv != TCORE_RETURN_SUCCESS) {
4397                 dbg("fail to send terminal response");
4398                 result = FALSE;
4399         }
4400
4401         g_free(tr);
4402         return result;
4403 }
4404
4405 static gboolean sat_manager_handle_send_dtmf_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
4406 {
4407         TReturn rv = TCORE_RETURN_FAILURE;
4408         gboolean result = FALSE;
4409
4410         gint resp;
4411         struct treq_sat_terminal_rsp_data *tr;
4412         struct sat_manager_queue_data q_data;
4413
4414         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
4415         if (!tr)
4416                 return result;
4417
4418         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
4419
4420         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
4421                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
4422                 g_free(tr);
4423                 return result;
4424         }
4425
4426         if (!exec_result) {
4427                 dbg("[SAT] get channel status data is null");
4428                 g_free(tr);
4429                 return result;
4430         }
4431
4432         if (!plg) {
4433                 dbg("there is no valid plugin at this point");
4434                 g_free(tr);
4435                 return result;
4436         }
4437
4438         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
4439         g_variant_get(exec_result, "(i)", &resp);
4440
4441         tr->cmd_number = q_data.cmd_data.send_dtmf.command_detail.cmd_num;
4442         tr->cmd_type = q_data.cmd_data.send_dtmf.command_detail.cmd_type;
4443         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));
4444
4445         tr->terminal_rsp_data.send_dtmf.device_id.src = DEVICE_ID_ME;
4446         tr->terminal_rsp_data.send_dtmf.device_id.dest = q_data.cmd_data.send_dtmf.device_id.src;
4447
4448         tr->terminal_rsp_data.send_dtmf.result_type = resp;
4449         switch (resp) {
4450         case RESULT_SUCCESS:
4451                 if (q_data.cmd_data.send_dtmf.icon_id.is_exist)
4452                         tr->terminal_rsp_data.send_dtmf.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
4453                 break;
4454
4455         case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
4456                 tr->terminal_rsp_data.send_dtmf.me_problem_type = ME_PROBLEM_NOT_IN_SPEECH_CALL;
4457                 break;
4458
4459         default:
4460                 tr->terminal_rsp_data.send_dtmf.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
4461                 tr->terminal_rsp_data.send_dtmf.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
4462                 break;
4463         }
4464
4465         result = TRUE;
4466         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
4467         if (rv != TCORE_RETURN_SUCCESS) {
4468                 dbg("fail to send terminal response");
4469                 result = FALSE;
4470         }
4471
4472         g_free(tr);
4473         return result;
4474 }
4475
4476 static gboolean sat_manager_handle_launch_browser_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
4477 {
4478         TReturn rv = TCORE_RETURN_FAILURE;
4479         gboolean result = FALSE;
4480
4481         gint resp, browser_problem;
4482         struct treq_sat_terminal_rsp_data *tr;
4483         struct sat_manager_queue_data q_data;
4484
4485         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
4486
4487         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
4488                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
4489                 return result;
4490         }
4491
4492         if (!exec_result) {
4493                 dbg("[SAT] get channel status data is null");
4494                 return result;
4495         }
4496
4497         if (!plg) {
4498                 dbg("there is no valid plugin at this point");
4499                 return result;
4500         }
4501
4502         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
4503         g_variant_get(exec_result, "(ii)", &resp, &browser_problem);
4504
4505         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
4506         if (!tr)
4507                 return result;
4508
4509         tr->cmd_number = q_data.cmd_data.launch_browser.command_detail.cmd_num;
4510         tr->cmd_type = q_data.cmd_data.launch_browser.command_detail.cmd_type;
4511         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));
4512
4513         tr->terminal_rsp_data.launch_browser.device_id.src = q_data.cmd_data.launch_browser.device_id.dest;
4514         tr->terminal_rsp_data.launch_browser.device_id.dest = q_data.cmd_data.launch_browser.device_id.src;
4515
4516         tr->terminal_rsp_data.launch_browser.result_type = resp;
4517         switch (resp) {
4518         case RESULT_SUCCESS:
4519                 if (q_data.cmd_data.launch_browser.user_confirm_icon_id.is_exist)
4520                         tr->terminal_rsp_data.launch_browser.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
4521
4522                 tr->terminal_rsp_data.launch_browser.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
4523                 tr->terminal_rsp_data.launch_browser.browser_problem_type = BROWSER_PROBLEM_NO_SPECIFIC_CAUSE;
4524                 break;
4525
4526         case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
4527                 tr->terminal_rsp_data.launch_browser.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
4528                 tr->terminal_rsp_data.launch_browser.browser_problem_type = BROWSER_PROBLEM_NO_SPECIFIC_CAUSE;
4529                 break;
4530
4531         case RESULT_LAUNCH_BROWSER_GENERIC_ERROR_CODE:
4532                 tr->terminal_rsp_data.launch_browser.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
4533                 tr->terminal_rsp_data.launch_browser.browser_problem_type = browser_problem;
4534                 break;
4535
4536         default:
4537                 tr->terminal_rsp_data.launch_browser.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
4538                 tr->terminal_rsp_data.launch_browser.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
4539                 tr->terminal_rsp_data.launch_browser.browser_problem_type = BROWSER_PROBLEM_NO_SPECIFIC_CAUSE;
4540                 break;
4541         }
4542
4543         result = TRUE;
4544         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
4545         if (rv != TCORE_RETURN_SUCCESS) {
4546                 dbg("fail to send terminal response");
4547                 result = FALSE;
4548         }
4549
4550         g_free(tr);
4551         return result;
4552 }
4553
4554 gboolean sat_manager_handle_app_exec_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gint command_type, GVariant *exec_result)
4555 {
4556         gboolean result = FALSE;
4557         GVariant *resp = NULL;
4558         dbg("[SAT] app exec result command id(%d) command type(%d)", command_id, command_type);
4559
4560         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
4561         g_variant_get(exec_result, "v", &resp);
4562
4563         switch (command_type) {
4564         case SAT_PROATV_CMD_SETUP_MENU:
4565                 result = _sat_manager_handle_setup_menu_result(ctx, plg, command_id, resp);
4566                 break;
4567
4568         case SAT_PROATV_CMD_DISPLAY_TEXT:
4569                 result = _sat_manager_handle_display_text_result(ctx, plg, command_id, resp);
4570                 break;
4571
4572         case SAT_PROATV_CMD_PLAY_TONE:
4573                 result = _sat_manager_handle_play_tone_result(ctx, plg, command_id, resp);
4574                 break;
4575
4576         case SAT_PROATV_CMD_SEND_SMS:
4577                 result = _sat_manager_handle_send_sms_result(ctx, plg, command_id, resp);
4578                 break;
4579
4580         case SAT_PROATV_CMD_SEND_SS:
4581                 result = _sat_manager_handle_send_ss_result(ctx, plg, command_id, resp);
4582                 break;
4583
4584         case SAT_PROATV_CMD_SEND_USSD:
4585                 result = _sat_manager_handle_send_ussd_result(ctx, plg, command_id, resp);
4586                 break;
4587
4588         case SAT_PROATV_CMD_SETUP_CALL:
4589                 result = _sat_manager_handle_setup_call_result(ctx, plg, command_id, resp);
4590                 break;
4591
4592         case SAT_PROATV_CMD_SETUP_IDLE_MODE_TEXT:
4593                 result = _sat_manager_handle_setup_idle_mode_text_result(ctx, plg, command_id, resp);
4594                 break;
4595
4596         case SAT_PROATV_CMD_OPEN_CHANNEL:
4597                 result = sat_manager_handle_open_channel_result(ctx, plg, command_id, resp);
4598                 break;
4599
4600         case SAT_PROATV_CMD_CLOSE_CHANNEL:
4601                 result = sat_manager_handle_close_channel_result(ctx, plg, command_id, resp);
4602                 break;
4603
4604         case SAT_PROATV_CMD_RECEIVE_DATA:
4605                 result = sat_manager_handle_receive_data_result(ctx, plg, command_id, resp);
4606                 break;
4607
4608         case SAT_PROATV_CMD_SEND_DATA:
4609                 result = sat_manager_handle_send_data_result(ctx, plg, command_id, resp);
4610                 break;
4611
4612         case SAT_PROATV_CMD_GET_CHANNEL_STATUS:
4613                 result = sat_manager_handle_get_channel_status_result(ctx, plg, command_id, resp);
4614                 break;
4615
4616         case SAT_PROATV_CMD_SEND_DTMF:
4617                 result = sat_manager_handle_send_dtmf_result(ctx, plg, command_id, resp);
4618                 break;
4619
4620         case SAT_PROATV_CMD_LAUNCH_BROWSER:
4621                 result = sat_manager_handle_launch_browser_result(ctx, plg, command_id, resp);
4622                 break;
4623
4624         default:
4625                 dbg("[SAT] invalid command type(%d)", command_type);
4626                 break;
4627         }
4628
4629         return result;
4630 }
4631
4632 static gboolean _sat_manager_handle_menu_select_confirm(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gint confirm_type, GVariant *addtional_data)
4633 {
4634         TReturn rv = TCORE_RETURN_FAILURE;
4635         gboolean result = FALSE;
4636
4637         gint item_id = 0;
4638         struct treq_sat_terminal_rsp_data *tr;
4639         struct sat_manager_queue_data q_data;
4640
4641         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
4642
4643         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
4644                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
4645                 return result;
4646         }
4647
4648         if (!plg) {
4649                 dbg("there is no valid plugin at this point");
4650                 return result;
4651         }
4652
4653         if (addtional_data) {
4654                 int local_index = 0;
4655                 guchar data;
4656                 GVariantIter *iter = NULL;
4657                 GVariant *inner_gv = NULL;
4658
4659                 inner_gv = g_variant_get_variant(addtional_data);
4660                 dbg("additional data exist type_format(%s)", g_variant_get_type_string(inner_gv));
4661
4662                 g_variant_get(inner_gv, "ay", &iter);
4663                 while (g_variant_iter_loop(iter, "y", &data)) {
4664                         dbg("index(%d) data(%d)", local_index, data);
4665                         item_id = data;
4666                         local_index++;
4667                 }
4668                 g_variant_iter_free(iter);
4669                 g_variant_unref(inner_gv);
4670         }
4671
4672         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
4673         if (!tr)
4674                 return result;
4675
4676         tr->cmd_number = q_data.cmd_data.selectItemInd.command_detail.cmd_num;
4677         tr->cmd_type = q_data.cmd_data.selectItemInd.command_detail.cmd_type;
4678         memcpy((void*)&tr->terminal_rsp_data.select_item.command_detail, &q_data.cmd_data.selectItemInd.command_detail, sizeof(struct tel_sat_cmd_detail_info));
4679         tr->terminal_rsp_data.select_item.device_id.src = DEVICE_ID_ME;
4680         tr->terminal_rsp_data.select_item.device_id.dest = DEVICE_ID_SIM;
4681
4682         switch (confirm_type) {
4683         case USER_CONFIRM_YES:
4684                 tr->terminal_rsp_data.select_item.item_identifier.item_identifier = item_id;
4685                 tr->terminal_rsp_data.select_item.other_info = FALSE;
4686                 tr->terminal_rsp_data.select_item.result_type = RESULT_SUCCESS;
4687                 tr->terminal_rsp_data.select_item.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
4688
4689                 if (q_data.cmd_data.selectItemInd.text_attribute.b_txt_attr || q_data.cmd_data.selectItemInd.text_attribute_list.list_cnt > 0)
4690                         tr->terminal_rsp_data.select_item.result_type = RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION;
4691
4692                 if (q_data.cmd_data.selectItemInd.icon_id.is_exist)
4693                         tr->terminal_rsp_data.select_item.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
4694
4695                 break;
4696
4697         case USER_CONFIRM_HELP_INFO:
4698                 tr->terminal_rsp_data.select_item.item_identifier.item_identifier = item_id;
4699                 tr->terminal_rsp_data.select_item.other_info = FALSE;
4700                 tr->terminal_rsp_data.select_item.result_type = RESULT_HELP_INFO_REQUIRED_BY_USER;
4701                 tr->terminal_rsp_data.select_item.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
4702                 /* TODO ctx->help_requested = TRUE; */
4703                 break;
4704
4705         case USER_CONFIRM_END:
4706                 tr->terminal_rsp_data.select_item.result_type = RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER;
4707                 break;
4708
4709         case USER_CONFIRM_NO_OR_CANCEL:
4710                 tr->terminal_rsp_data.select_item.result_type = RESULT_BACKWARD_MOVE_BY_USER;
4711                 break;
4712
4713         case USER_CONFIRM_TIMEOUT:
4714                 tr->terminal_rsp_data.select_item.result_type = RESULT_NO_RESPONSE_FROM_USER;
4715                 break;
4716
4717         default:
4718                 dbg("not handled value[%d] here", confirm_type);
4719                 break;
4720         }
4721
4722         result = TRUE;
4723         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
4724         if (rv != TCORE_RETURN_SUCCESS) {
4725                 dbg("fail to send terminal response");
4726                 result = FALSE;
4727         }
4728
4729         g_free(tr);
4730
4731         return result;
4732 }
4733
4734 static gboolean _sat_manager_handle_display_text_confirm(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gint confirm_type, GVariant *addtional_data)
4735 {
4736         TReturn rv = TCORE_RETURN_FAILURE;
4737         gboolean result = FALSE;
4738
4739         struct treq_sat_terminal_rsp_data *tr;
4740         struct sat_manager_queue_data q_data;
4741
4742         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
4743
4744         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
4745                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
4746                 return result;
4747         }
4748
4749         if (!plg) {
4750                 dbg("there is no valid plugin at this point");
4751                 return result;
4752         }
4753
4754         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
4755         if (!tr)
4756                 return result;
4757
4758         tr->cmd_number = q_data.cmd_data.displayTextInd.command_detail.cmd_num;
4759         tr->cmd_type = q_data.cmd_data.displayTextInd.command_detail.cmd_type;
4760         memcpy((void*)&tr->terminal_rsp_data.display_text.command_detail, &q_data.cmd_data.displayTextInd.command_detail, sizeof(struct tel_sat_cmd_detail_info));
4761         tr->terminal_rsp_data.display_text.device_id.src = DEVICE_ID_ME;
4762         tr->terminal_rsp_data.display_text.device_id.dest = DEVICE_ID_SIM;
4763
4764         switch (confirm_type) {
4765         case USER_CONFIRM_YES: {
4766                 tr->terminal_rsp_data.display_text.result_type = RESULT_SUCCESS;
4767                 tr->terminal_rsp_data.display_text.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
4768
4769                 if (q_data.cmd_data.displayTextInd.text_attribute.b_txt_attr)
4770                         tr->terminal_rsp_data.display_text.result_type = RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION;
4771
4772                 if (q_data.cmd_data.displayTextInd.icon_id.is_exist)
4773                         tr->terminal_rsp_data.display_text.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
4774         } break;
4775
4776         case USER_CONFIRM_NO_OR_CANCEL:
4777                 tr->terminal_rsp_data.display_text.result_type = RESULT_BACKWARD_MOVE_BY_USER;
4778                 break;
4779
4780         case USER_CONFIRM_TIMEOUT:
4781                 tr->terminal_rsp_data.display_text.result_type = RESULT_SUCCESS;
4782
4783                 if (q_data.cmd_data.displayTextInd.command_detail.cmd_qualifier.display_text.text_clear_type == TEXT_WAIT_FOR_USER_TO_CLEAR_MSG)
4784                         tr->terminal_rsp_data.display_text.result_type = RESULT_NO_RESPONSE_FROM_USER;
4785                 break;
4786
4787         case USER_CONFIRM_END:
4788                 tr->terminal_rsp_data.display_text.result_type = RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER;
4789                 break;
4790
4791         case USER_CONFIRM_HELP_INFO:
4792         default:
4793                 dbg("not handled value[%d] here", confirm_type);
4794                 break;
4795         }
4796
4797         result = TRUE;
4798         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
4799         if (rv != TCORE_RETURN_SUCCESS) {
4800                 dbg("fail to send terminal response");
4801                 result = FALSE;
4802         }
4803
4804         g_free(tr);
4805
4806         return result;
4807 }
4808
4809 static gboolean _sat_manager_handle_get_inkey_confirm(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gint confirm_type, GVariant *addtional_data)
4810 {
4811         TReturn rv = TCORE_RETURN_FAILURE;
4812         gboolean result = FALSE;
4813
4814         gint inkey_data_len = 0;
4815         gchar inkey_data[SAT_TEXT_STRING_LEN_MAX];
4816         struct treq_sat_terminal_rsp_data *tr;
4817         struct sat_manager_queue_data q_data;
4818
4819         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
4820         memset(inkey_data, 0, SAT_TEXT_STRING_LEN_MAX);
4821
4822         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
4823                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
4824                 return result;
4825         }
4826
4827         if (!plg) {
4828                 dbg("there is no valid plugin at this point");
4829                 return result;
4830         }
4831
4832         if (addtional_data) {
4833                 int local_index = 0;
4834                 guchar data;
4835                 GVariantIter *iter = NULL;
4836                 GVariant *inner_gv = NULL;
4837
4838                 inner_gv = g_variant_get_variant(addtional_data);
4839                 dbg("additional data exist type_format(%s)", g_variant_get_type_string(inner_gv));
4840
4841                 g_variant_get(inner_gv, "ay", &iter);
4842                 while (g_variant_iter_loop(iter, "y", &data)) {
4843                         dbg("index(%d) data(%d)", local_index, data);
4844                         inkey_data[local_index] = data;
4845                         local_index++;
4846                 }
4847                 g_variant_iter_free(iter);
4848                 g_variant_unref(inner_gv);
4849                 inkey_data_len = local_index;
4850         }
4851
4852         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
4853         if (!tr)
4854                 return result;
4855
4856         tr->cmd_number = q_data.cmd_data.getInkeyInd.command_detail.cmd_num;
4857         tr->cmd_type = q_data.cmd_data.getInkeyInd.command_detail.cmd_type;
4858         memcpy((void*)&tr->terminal_rsp_data.get_inkey.command_detail, &q_data.cmd_data.getInkeyInd.command_detail, sizeof(struct tel_sat_cmd_detail_info));
4859         tr->terminal_rsp_data.get_inkey.device_id.src = DEVICE_ID_ME;
4860         tr->terminal_rsp_data.get_inkey.device_id.dest = DEVICE_ID_SIM;
4861
4862         switch (confirm_type) {
4863         case USER_CONFIRM_YES:
4864                 tr->terminal_rsp_data.get_inkey.result_type = RESULT_SUCCESS;
4865
4866                 if (q_data.cmd_data.getInkeyInd.text_attribute.b_txt_attr)
4867                         tr->terminal_rsp_data.get_inkey.result_type = RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION;
4868
4869                 if (q_data.cmd_data.getInkeyInd.icon_id.is_exist)
4870                         tr->terminal_rsp_data.get_inkey.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
4871
4872                 if (q_data.cmd_data.getInkeyInd.command_detail.cmd_qualifier.get_inkey.inkey_type == INKEY_TYPE_YES_NO_REQUESTED) {
4873                         tr->terminal_rsp_data.get_inkey.text.dcs.m_class = MSG_CLASS_RESERVED;
4874                         tr->terminal_rsp_data.get_inkey.text.dcs.a_format = ALPHABET_FORMAT_8BIT_DATA;
4875                         tr->terminal_rsp_data.get_inkey.text.string_length = 1;
4876                         tr->terminal_rsp_data.get_inkey.text.string[0] = 0x01;
4877                 } else if (inkey_data_len > 0) {
4878                         tr->terminal_rsp_data.get_inkey.text.string_length = inkey_data_len;
4879
4880                         if (!q_data.cmd_data.getInkeyInd.command_detail.cmd_qualifier.get_inkey.alphabet_set) {
4881                                 tr->terminal_rsp_data.get_inkey.text.is_digit_only = TRUE;
4882                                 tr->terminal_rsp_data.get_inkey.text.dcs.a_format = ALPHABET_FORMAT_8BIT_DATA;
4883                                 tr->terminal_rsp_data.get_inkey.text.dcs.m_class = MSG_CLASS_RESERVED;
4884
4885                                 memcpy((void*)tr->terminal_rsp_data.get_inkey.text.string, inkey_data, inkey_data_len);
4886                         } else {
4887                                 tr->terminal_rsp_data.get_inkey.text.dcs.m_class = MSG_CLASS_RESERVED;
4888
4889                                 if (q_data.cmd_data.getInkeyInd.command_detail.cmd_qualifier.get_inkey.alphabet_type == INPUT_ALPHABET_TYPE_SMS_DEFAULT) {
4890                                         int tmp_len;
4891                                         char tmp_str[SAT_TEXT_STRING_LEN_MAX + 1], *packed_data;
4892
4893                                         dbg("sat gsm7 encoding");
4894                                         tcore_util_convert_utf8_to_gsm((unsigned char*) tmp_str, &tmp_len, (unsigned char*)inkey_data, inkey_data_len);
4895                                         packed_data = (char*) tcore_util_pack_gsm7bit((const unsigned char *)tmp_str, tmp_len);
4896
4897                                         if (packed_data) {
4898                                                 tr->terminal_rsp_data.get_inkey.text.dcs.a_format = ALPHABET_FORMAT_8BIT_DATA;
4899                                                 tr->terminal_rsp_data.get_inkey.text.string_length = strlen(packed_data);
4900                                                 memcpy((void*) tr->terminal_rsp_data.get_inkey.text.string, packed_data, strlen(packed_data));
4901                                                 g_free(packed_data);
4902                                         }
4903                                 } else if (q_data.cmd_data.getInkeyInd.command_detail.cmd_qualifier.get_inkey.alphabet_type == INPUT_ALPHABET_TYPE_UCS2) {
4904                                         char *tmp = NULL;
4905                                         dbg("UCS2 DATA");
4906
4907                                         tr->terminal_rsp_data.get_inkey.text.dcs.a_format = ALPHABET_FORMAT_UCS2;
4908                                         tcore_util_convert_utf8_to_ucs2(&tmp,
4909                                                 &tr->terminal_rsp_data.get_inkey.text.string_length, (unsigned char*)inkey_data, inkey_data_len);
4910
4911                                         memcpy(tr->terminal_rsp_data.get_inkey.text.string, tmp, tr->terminal_rsp_data.get_inkey.text.string_length);
4912                                         g_free(tmp);
4913                                 } else {
4914                                         tr->terminal_rsp_data.get_inkey.text.dcs.a_format = ALPHABET_FORMAT_RESERVED;
4915                                         dbg("[SAT] invalid DCS[%d]", tr->terminal_rsp_data.get_inkey.text.dcs.a_format);
4916                                 }
4917                         }
4918                 }
4919                 break;
4920
4921         case USER_CONFIRM_HELP_INFO:
4922                 tr->terminal_rsp_data.get_inkey.result_type = RESULT_HELP_INFO_REQUIRED_BY_USER;
4923                 /* TODO ctx->help_requested = TRUE; */
4924                 break;
4925
4926         case USER_CONFIRM_NO_OR_CANCEL:
4927                 tr->terminal_rsp_data.get_inkey.result_type = RESULT_BACKWARD_MOVE_BY_USER;
4928
4929                 if (q_data.cmd_data.getInkeyInd.command_detail.cmd_qualifier.get_inkey.inkey_type == INKEY_TYPE_YES_NO_REQUESTED) {
4930                         tr->terminal_rsp_data.get_inkey.result_type = RESULT_SUCCESS;
4931                         tr->terminal_rsp_data.get_inkey.text.dcs.m_class = MSG_CLASS_RESERVED;
4932                         tr->terminal_rsp_data.get_inkey.text.dcs.a_format = ALPHABET_FORMAT_8BIT_DATA;
4933                         tr->terminal_rsp_data.get_inkey.text.string_length = 1;
4934                         tr->terminal_rsp_data.get_inkey.text.string[0] = 0x00;
4935                 }
4936                 break;
4937
4938         case USER_CONFIRM_TIMEOUT:
4939                 tr->terminal_rsp_data.get_inkey.result_type = RESULT_NO_RESPONSE_FROM_USER;
4940                 if (q_data.cmd_data.getInkeyInd.duration.time_interval != 0) {
4941                         tr->terminal_rsp_data.get_inkey.duration.time_interval = q_data.cmd_data.getInkeyInd.duration.time_interval;
4942                         tr->terminal_rsp_data.get_inkey.duration.time_unit = q_data.cmd_data.getInkeyInd.duration.time_unit;
4943                 }
4944                 break;
4945
4946         case USER_CONFIRM_END:
4947                 tr->terminal_rsp_data.get_inkey.result_type = RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER;
4948                 break;
4949
4950         default:
4951                 dbg("not handled value[%d] here", confirm_type);
4952                 break;
4953         }
4954
4955         result = TRUE;
4956         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
4957         if (rv != TCORE_RETURN_SUCCESS) {
4958                 dbg("fail to send terminal response");
4959                 result = FALSE;
4960         }
4961
4962         g_free(tr);
4963
4964         return result;
4965 }
4966
4967 static gboolean _sat_manager_handle_get_input_confirm(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gint confirm_type, GVariant *addtional_data)
4968 {
4969         TReturn rv = TCORE_RETURN_FAILURE;
4970         gboolean result = FALSE;
4971
4972         gint input_data_len = 0;
4973         gchar input_data[SAT_TEXT_STRING_LEN_MAX];
4974         struct treq_sat_terminal_rsp_data *tr;
4975         struct sat_manager_queue_data q_data;
4976
4977         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
4978         memset(input_data, 0, SAT_TEXT_STRING_LEN_MAX);
4979
4980         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
4981                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
4982                 return result;
4983         }
4984
4985         if (!plg) {
4986                 dbg("there is no valid plugin at this point");
4987                 return result;
4988         }
4989
4990         if (addtional_data) {
4991                 int local_index = 0;
4992                 guchar data;
4993                 GVariantIter *iter = NULL;
4994                 GVariant *inner_gv = NULL;
4995
4996                 inner_gv = g_variant_get_variant(addtional_data);
4997                 dbg("additional data exist type_format(%s)", g_variant_get_type_string(inner_gv));
4998
4999                 g_variant_get(inner_gv, "ay", &iter);
5000                 while (g_variant_iter_loop(iter, "y", &data)) {
5001                         dbg("index(%d) data(%d)", local_index, data);
5002                         input_data[local_index] = data;
5003                         local_index++;
5004                 }
5005                 g_variant_iter_free(iter);
5006                 g_variant_unref(inner_gv);
5007                 input_data_len = local_index;
5008         }
5009
5010         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
5011         if (!tr)
5012                 return result;
5013
5014         tr->cmd_number = q_data.cmd_data.getInputInd.command_detail.cmd_num;
5015         tr->cmd_type = q_data.cmd_data.getInputInd.command_detail.cmd_type;
5016         memcpy((void*)&tr->terminal_rsp_data.get_input.command_detail, &q_data.cmd_data.getInputInd.command_detail, sizeof(struct tel_sat_cmd_detail_info));
5017         tr->terminal_rsp_data.get_input.device_id.src = DEVICE_ID_ME;
5018         tr->terminal_rsp_data.get_input.device_id.dest = DEVICE_ID_SIM;
5019
5020         switch (confirm_type) {
5021         case USER_CONFIRM_YES:
5022                 tr->terminal_rsp_data.get_input.result_type = RESULT_SUCCESS;
5023                 tr->terminal_rsp_data.get_input.text.dcs.m_class = MSG_CLASS_RESERVED;
5024
5025                 if (!q_data.cmd_data.getInputInd.command_detail.cmd_qualifier.get_input.alphabet_set)
5026                         tr->terminal_rsp_data.get_input.text.is_digit_only = TRUE;
5027
5028                 if (q_data.cmd_data.getInputInd.text_attribute.b_txt_attr)
5029                         tr->terminal_rsp_data.get_input.result_type = RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION;
5030
5031                 if (q_data.cmd_data.getInputInd.icon_id.is_exist)
5032                         tr->terminal_rsp_data.get_input.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
5033
5034                 if (!q_data.cmd_data.getInputInd.command_detail.cmd_qualifier.get_input.user_input_unpacked_format) {
5035                         dbg("[SAT] packing to SMS7 default");
5036
5037                         tr->terminal_rsp_data.get_input.text.string_length = 0;
5038                         tr->terminal_rsp_data.get_input.text.dcs.a_format = ALPHABET_FORMAT_SMS_DEFAULT;
5039
5040                         if (input_data_len > 0) {
5041                                 int tmp_len;
5042                                 char tmp_str[SAT_TEXT_STRING_LEN_MAX + 1], *packed_data;
5043
5044                                 dbg("sat gsm7 encoding");
5045                                 tcore_util_convert_utf8_to_gsm((unsigned char*)tmp_str, &tmp_len, (unsigned char*)input_data, input_data_len);
5046                                 packed_data = (char*) tcore_util_pack_gsm7bit((const unsigned char *)tmp_str, tmp_len);
5047
5048                                 if (packed_data) {
5049                                         memcpy((void*)tr->terminal_rsp_data.get_input.text.string, packed_data, strlen(packed_data));
5050                                         tr->terminal_rsp_data.get_input.text.string_length = strlen(packed_data);
5051
5052                                         g_free(packed_data);
5053                                 }
5054                         }
5055                 } else {
5056                         dbg("[SAT] packing not required");
5057
5058                         if (q_data.cmd_data.getInkeyInd.command_detail.cmd_qualifier.get_input.alphabet_type == INPUT_ALPHABET_TYPE_SMS_DEFAULT) {
5059                                 tr->terminal_rsp_data.get_input.text.dcs.a_format = ALPHABET_FORMAT_8BIT_DATA;
5060                                 tcore_util_convert_utf8_to_gsm((unsigned char*)tr->terminal_rsp_data.get_input.text.string,
5061                                         &tr->terminal_rsp_data.get_input.text.string_length, (unsigned char*)input_data, input_data_len);
5062                         } else if (q_data.cmd_data.getInkeyInd.command_detail.cmd_qualifier.get_input.alphabet_type == INPUT_ALPHABET_TYPE_UCS2) {
5063                                 char *tmp = NULL;
5064
5065                                 tr->terminal_rsp_data.get_input.text.dcs.a_format = ALPHABET_FORMAT_UCS2;
5066                                 tcore_util_convert_utf8_to_ucs2(&tmp, &tr->terminal_rsp_data.get_input.text.string_length, (unsigned char*)input_data, input_data_len);
5067                                 memcpy(tr->terminal_rsp_data.get_input.text.string, tmp, tr->terminal_rsp_data.get_input.text.string_length);
5068                                 g_free(tmp);
5069                         } else {
5070                                 tr->terminal_rsp_data.get_input.text.dcs.a_format = ALPHABET_FORMAT_RESERVED;
5071                                 dbg("[SAT] invalid DCS[%d]", tr->terminal_rsp_data.get_input.text.dcs.a_format);
5072                         }
5073                 } break;
5074
5075         case USER_CONFIRM_HELP_INFO:
5076                 tr->terminal_rsp_data.get_input.result_type = RESULT_HELP_INFO_REQUIRED_BY_USER;
5077                 /* TODO ctx->help_requested = TRUE; */
5078                 break;
5079
5080         case USER_CONFIRM_NO_OR_CANCEL:
5081                 tr->terminal_rsp_data.get_input.result_type = RESULT_BACKWARD_MOVE_BY_USER;
5082                 break;
5083
5084         case USER_CONFIRM_TIMEOUT:
5085                 tr->terminal_rsp_data.get_input.result_type = RESULT_NO_RESPONSE_FROM_USER;
5086                 break;
5087
5088         case USER_CONFIRM_END:
5089                 tr->terminal_rsp_data.get_input.result_type = RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER;
5090                 break;
5091         default:
5092                 break;
5093         }
5094
5095         result = TRUE;
5096         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
5097         if (rv != TCORE_RETURN_SUCCESS) {
5098                 dbg("fail to send terminal response");
5099                 result = FALSE;
5100         }
5101
5102         g_free(tr);
5103
5104         return result;
5105 }
5106
5107 static gboolean _sat_manager_handle_setup_call_confirm(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gint confirm_type, GVariant *addtional_data)
5108 {
5109         TReturn rv = TCORE_RETURN_FAILURE;
5110         gboolean result = FALSE;
5111
5112         gint input_data_len = 0;
5113         gchar input_data[SAT_TEXT_STRING_LEN_MAX];
5114         struct treq_sat_terminal_rsp_data *tr;
5115         struct sat_manager_queue_data q_data;
5116
5117         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
5118         memset(input_data, 0, SAT_TEXT_STRING_LEN_MAX);
5119
5120         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
5121                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
5122                 return result;
5123         }
5124
5125         if (!plg) {
5126                 dbg("there is no valid plugin at this point");
5127                 return result;
5128         }
5129
5130         if (addtional_data) {
5131                 int local_index = 0;
5132                 guchar data;
5133                 GVariantIter *iter = NULL;
5134                 GVariant *inner_gv = NULL;
5135
5136                 inner_gv = g_variant_get_variant(addtional_data);
5137                 dbg("additional data exist type_format(%s)", g_variant_get_type_string(inner_gv));
5138
5139                 g_variant_get(inner_gv, "ay", &iter);
5140                 while (g_variant_iter_loop(iter, "y", &data)) {
5141                         dbg("index(%d) data(%d)", local_index, data);
5142                         input_data[local_index] = data;
5143                         local_index++;
5144                 }
5145                 g_variant_iter_free(iter);
5146                 g_variant_unref(inner_gv);
5147                 input_data_len = local_index;
5148                 dbg("input_data_len=[%d]", input_data_len);
5149         }
5150
5151         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
5152         if (!tr)
5153                 return result;
5154
5155         tr->cmd_number = q_data.cmd_data.setup_call.command_detail.cmd_num;
5156         tr->cmd_type = q_data.cmd_data.setup_call.command_detail.cmd_type;
5157         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));
5158         tr->terminal_rsp_data.setup_call.device_id.src = DEVICE_ID_ME;
5159         tr->terminal_rsp_data.setup_call.device_id.dest = q_data.cmd_data.setup_call.device_id.src;
5160
5161         switch (confirm_type) {
5162         case USER_CONFIRM_YES:{
5163                 char *path;
5164                 TelephonySAT *sat;
5165                 TelephonyObjectSkeleton *object;
5166                 const gchar *cp_name;
5167                 GVariant *setup_call = NULL;
5168                 gint command_id, call_type, confirmed_text_len, text_len, duration;
5169                 gchar *confirmed_text = NULL, *text = NULL, *call_number = NULL;
5170 #if defined(TIZEN_SUPPORT_SAT_ICON)
5171                 GVariant *icon_id;
5172 #endif
5173
5174                 cp_name = tcore_server_get_cp_name_by_plugin(plg);
5175                 if (cp_name == NULL) {
5176                         err("CP name is NULL");
5177                         goto Exit;
5178                 }
5179
5180                 dbg("CP Name: [%s]", cp_name);
5181                 path = g_strdup_printf("%s/%s", MY_DBUS_PATH, cp_name);
5182
5183                 /* Look-up Hash table for Object */
5184                 object = g_hash_table_lookup(ctx->objects, path);
5185                 dbg("Path: [%s] Interface object: [%p]", path, object);
5186                 g_free(path);
5187                 if (object == NULL) {
5188                         err("Object is NOT defined!!!");
5189                         goto Exit;
5190                 }
5191
5192                 sat = telephony_object_peek_sat(TELEPHONY_OBJECT(object));
5193
5194                 setup_call = sat_manager_setup_call_noti(ctx, cp_name, &q_data.cmd_data.setup_call);
5195
5196                 dbg("setup call type_format(%s)", g_variant_get_type_string(setup_call));
5197 #if defined(TIZEN_SUPPORT_SAT_ICON)
5198                 g_variant_get(setup_call, "(isisi@visi)", &command_id,
5199                         &confirmed_text, &confirmed_text_len, &text, &text_len,
5200                         &icon_id, &call_type, &call_number, &duration);
5201
5202                 telephony_sat_emit_setup_call(sat, command_id, confirmed_text,
5203                         confirmed_text_len, text, text_len, icon_id, call_type,
5204                         call_number, duration);
5205 #else
5206                 g_variant_get(setup_call, "(isisiisi)", &command_id,
5207                         &confirmed_text, &confirmed_text_len, &text, &text_len,
5208                         &call_type, &call_number, &duration);
5209
5210                 telephony_sat_emit_setup_call(sat, command_id, confirmed_text,
5211                         confirmed_text_len, text, text_len, call_type,
5212                         call_number, duration);
5213 #endif
5214                 g_free(confirmed_text);
5215                 g_free(text);
5216                 g_free(call_number);
5217
5218                 free(tr);
5219
5220                 dbg("user confirmation %d", USER_CONFIRM_YES);
5221                 return TRUE;
5222         }
5223
5224         case USER_CONFIRM_NO_OR_CANCEL: {
5225                 tr->terminal_rsp_data.setup_call.result_type = RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER;
5226         } break;
5227
5228         case USER_CONFIRM_END: {
5229                 tr->terminal_rsp_data.setup_call.result_type = RESULT_USER_DID_NOT_ACCEPT_CALL_SETUP_REQ;
5230         } break;
5231
5232         case USER_CONFIRM_HELP_INFO:
5233         default:
5234                 tr->terminal_rsp_data.setup_call.result_type = RESULT_NO_RESPONSE_FROM_USER;
5235                 break;
5236         }
5237
5238         result = TRUE;
5239         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
5240         if (rv != TCORE_RETURN_SUCCESS) {
5241                 dbg("fail to send terminal response");
5242                 result = FALSE;
5243         }
5244
5245 Exit:
5246         free(tr);
5247         return result;
5248 }
5249
5250 static gboolean _sat_manager_handle_send_dtmf_confirm(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gint confirm_type, GVariant *addtional_data)
5251 {
5252         TReturn rv = TCORE_RETURN_FAILURE;
5253         gboolean result = FALSE;
5254
5255         struct treq_sat_terminal_rsp_data *tr;
5256         struct sat_manager_queue_data q_data;
5257
5258         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
5259
5260         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
5261                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
5262                 return result;
5263         }
5264
5265         if (!plg) {
5266                 dbg("there is no valid plugin at this point");
5267                 return result;
5268         }
5269
5270         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
5271         if (!tr)
5272                 return result;
5273
5274         tr->cmd_number = q_data.cmd_data.send_dtmf.command_detail.cmd_num;
5275         tr->cmd_type = q_data.cmd_data.send_dtmf.command_detail.cmd_type;
5276         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));
5277         tr->terminal_rsp_data.send_dtmf.device_id.src = DEVICE_ID_ME;
5278         tr->terminal_rsp_data.send_dtmf.device_id.dest = q_data.cmd_data.send_dtmf.device_id.src;
5279
5280         dbg("confirm_type[%d]", confirm_type);
5281
5282         switch (confirm_type) {
5283         case USER_CONFIRM_NO_OR_CANCEL:
5284         case USER_CONFIRM_END:
5285                 tr->terminal_rsp_data.send_dtmf.result_type = RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER;
5286                 tr->terminal_rsp_data.send_dtmf.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
5287                 break;
5288         default:
5289                 tr->terminal_rsp_data.send_dtmf.result_type = RESULT_NO_RESPONSE_FROM_USER;
5290                 break;
5291         }
5292
5293         result = TRUE;
5294         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
5295         if (rv != TCORE_RETURN_SUCCESS) {
5296                 dbg("fail to send terminal response");
5297                 result = FALSE;
5298         }
5299         g_free(tr);
5300
5301         return result;
5302 }
5303
5304 static gboolean _sat_manager_handle_launch_browser_confirm(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gint confirm_type, GVariant *addtional_data)
5305 {
5306         TReturn rv = TCORE_RETURN_FAILURE;
5307         gboolean result = FALSE;
5308
5309         struct treq_sat_terminal_rsp_data *tr;
5310         struct sat_manager_queue_data q_data;
5311
5312         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
5313
5314         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
5315                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
5316                 return result;
5317         }
5318
5319         if (!plg) {
5320                 dbg("there is no valid plugin at this point");
5321                 return result;
5322         }
5323
5324         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
5325         if (!tr)
5326                 return result;
5327
5328         tr->cmd_number = q_data.cmd_data.launch_browser.command_detail.cmd_num;
5329         tr->cmd_type = q_data.cmd_data.launch_browser.command_detail.cmd_type;
5330         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));
5331         tr->terminal_rsp_data.launch_browser.device_id.src = q_data.cmd_data.launch_browser.device_id.dest;
5332         tr->terminal_rsp_data.launch_browser.device_id.dest = q_data.cmd_data.launch_browser.device_id.src;
5333
5334         dbg("confirm_type[%d]", confirm_type);
5335
5336         switch (confirm_type) {
5337                 case USER_CONFIRM_YES:{
5338                         char *path;
5339                         TelephonySAT *sat;
5340                         TelephonyObjectSkeleton *object;
5341
5342                         const gchar *cp_name;
5343                         GVariant *launch_browser = NULL;
5344
5345                         gint command_id = 0;
5346                         gint browser_launch_type = 0, browser_id = 0;
5347                         gint url_len = 0, text_len = 0, gateway_proxy_len = 0;
5348                         gchar *url = NULL;
5349                         gchar *text = NULL;
5350                         gchar *gateway_proxy = NULL;
5351 #if defined(TIZEN_SUPPORT_SAT_ICON)
5352                         GVariant *icon_id = NULL;
5353 #endif
5354                         enum dbus_tapi_sim_slot_id slot_id;
5355
5356                         cp_name = tcore_server_get_cp_name_by_plugin(plg);
5357                         if (cp_name == NULL) {
5358                                 err("CP name is NULL");
5359                                 goto Exit;
5360                         }
5361
5362                         dbg("CP Name: [%s]", cp_name);
5363                         path = g_strdup_printf("%s/%s", MY_DBUS_PATH, cp_name);
5364
5365                         /* Look-up Hash table for Object */
5366                         object = g_hash_table_lookup(ctx->objects, path);
5367                         dbg("Path: [%s] Interface object: [%p]", path, object);
5368                         g_free(path);
5369                         if (object == NULL) {
5370                                 err("Object is NOT defined!!!");
5371                                 goto Exit;
5372                         }
5373                         sat = telephony_object_peek_sat(TELEPHONY_OBJECT(object));
5374
5375                         launch_browser = sat_manager_launch_browser_noti(ctx, cp_name, &q_data.cmd_data.launch_browser);
5376
5377                         dbg("launch_browser type_format(%s)", g_variant_get_type_string(launch_browser));
5378 #if defined(TIZEN_SUPPORT_SAT_ICON)
5379                         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);
5380
5381                         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);
5382 #else
5383                         g_variant_get(launch_browser, "(iiisisisi)", &command_id, &browser_launch_type, &browser_id, &url, &url_len, &gateway_proxy, &gateway_proxy_len, &text, &text_len);
5384
5385                         telephony_sat_emit_launch_browser(sat, command_id, browser_launch_type, browser_id, url, url_len, gateway_proxy, gateway_proxy_len, text, text_len);
5386 #endif
5387                         g_free(url);
5388                         g_free(text);
5389                         g_free(gateway_proxy);
5390
5391                         slot_id = get_sim_slot_id_by_cp_name(tcore_server_get_cp_name_by_plugin(plg));
5392                         dbg("slot_id: [%d]", slot_id);
5393
5394                         sat_ui_support_launch_browser_application(q_data.cmd_data.launch_browser.command_detail.cmd_type, launch_browser, slot_id);
5395
5396                         g_free(tr);
5397                         return TRUE;
5398                 } break;
5399
5400                 case USER_CONFIRM_NO_OR_CANCEL:
5401                         tr->terminal_rsp_data.launch_browser.result_type = RESULT_USER_DID_NOT_ACCEPT_CALL_SETUP_REQ;
5402                         break;
5403                 case USER_CONFIRM_END:
5404                         tr->terminal_rsp_data.launch_browser.result_type = RESULT_LAUNCH_BROWSER_GENERIC_ERROR_CODE;
5405                         break;
5406
5407                 default:
5408                         tr->terminal_rsp_data.launch_browser.result_type = RESULT_NO_RESPONSE_FROM_USER;
5409                         break;
5410         }
5411
5412         result = TRUE;
5413         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
5414         if (rv != TCORE_RETURN_SUCCESS) {
5415                 dbg("fail to send terminal response");
5416                 result = FALSE;
5417         }
5418 Exit:
5419         g_free(tr);
5420         return result;
5421 }
5422 #if !defined(TIZEN_PLATFORM_USE_QCOM_QMI)
5423 static gboolean _sat_manager_handle_open_channel_confirm(struct custom_data *ctx,
5424                 TcorePlugin *plg, gint command_id, gint confirm_type, GVariant *addtional_data)
5425 {
5426         TReturn rv = TCORE_RETURN_FAILURE;
5427         gboolean result = FALSE;
5428
5429         struct treq_sat_terminal_rsp_data *tr;
5430         struct sat_manager_queue_data q_data;
5431
5432         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
5433
5434         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
5435                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
5436                 return result;
5437         }
5438
5439         if (!plg) {
5440                 dbg("there is no valid plugin at this point");
5441                 return result;
5442         }
5443
5444         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
5445         if (!tr)
5446                 return result;
5447
5448         tr->cmd_number = q_data.cmd_data.open_channel.command_detail.cmd_num;
5449         tr->cmd_type = q_data.cmd_data.open_channel.command_detail.cmd_type;
5450         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));
5451         tr->terminal_rsp_data.open_channel.device_id.src = q_data.cmd_data.send_dtmf.device_id.dest;
5452         tr->terminal_rsp_data.open_channel.device_id.dest = q_data.cmd_data.send_dtmf.device_id.src;
5453
5454         dbg("confirm_type[%d]", confirm_type);
5455
5456         switch (confirm_type) {
5457         case USER_CONFIRM_YES:{
5458                 char *path;
5459                 TelephonyObjectSkeleton *object;
5460                 const gchar *cp_name;
5461                 GVariant *open_channel = NULL;
5462                 gint command_id, bearer_type, protocol_type, dest_addr_type;
5463                 gboolean immediate_link, auto_reconnection, bg_mode;
5464                 gint text_len, buffer_size, port_number;
5465                 gchar *text = NULL, *dest_address = NULL;
5466 #if defined(TIZEN_SUPPORT_SAT_ICON)
5467                 GVariant *icon_id;
5468 #endif
5469                 GVariant *bearer_param;
5470                 GVariant *bearer_detail;
5471
5472                 /* emit send_dtmf signal */
5473                 cp_name = tcore_server_get_cp_name_by_plugin(plg);
5474                 if (cp_name == NULL) {
5475                         err("CP name is NULL");
5476                         goto Exit;
5477                 }
5478
5479                 dbg("CP Name: [%s]", cp_name);
5480                 path = g_strdup_printf("%s/%s", MY_DBUS_PATH, cp_name);
5481
5482                 /* Look-up Hash table for Object */
5483                 object = g_hash_table_lookup(ctx->objects, path);
5484                 dbg("Path: [%s] Interface object: [%p]", path, object);
5485                 g_free(path);
5486                 if (object == NULL) {
5487                         err("Object is NOT defined!!!");
5488                         goto Exit;
5489                 }
5490
5491                 open_channel = sat_manager_open_channel_noti(ctx, cp_name, &q_data.cmd_data.open_channel);
5492
5493                 dbg("open channel type_format(%s)", g_variant_get_type_string(open_channel));
5494 #if defined(TIZEN_SUPPORT_SAT_ICON)
5495                 g_variant_get(open_channel, "(isi@vbbbi@viiiis@v)", &command_id,
5496                         &text, &text_len, &icon_id, &immediate_link, &auto_reconnection, &bg_mode,
5497                         &bearer_type, &bearer_param, &buffer_size, &protocol_type, &port_number,
5498                         &dest_addr_type, &dest_address, &bearer_detail);
5499 #else
5500                 g_variant_get(open_channel, "(isibbbi@viiiis@v)", &command_id,
5501                         &text, &text_len, &immediate_link, &auto_reconnection, &bg_mode,
5502                         &bearer_type, &bearer_param, &buffer_size, &protocol_type,
5503                         &port_number, &dest_addr_type, &dest_address, &bearer_detail);
5504 #endif
5505                 /* telephony_sat_emit_open_channel(sat, command_id, text, text_len,
5506                         immediate_link, auto_reconnection, bg_mode, bearer_type,
5507                         bearer_param, buffer_size, protocol_type, port_number,
5508                         dest_addr_type, dest_address, bearer_detail); */
5509
5510                 g_free(text);
5511                 g_free(dest_address);
5512                 /* BIP Manager */
5513                 {
5514                         GDBusConnection *conn = NULL;
5515                         const gchar *g_path = NULL;
5516
5517                         conn = g_dbus_object_manager_server_get_connection(ctx->manager);
5518                         g_path = g_dbus_object_get_object_path(G_DBUS_OBJECT(object));
5519
5520                         sat_ui_support_exec_bip(conn, g_path, SAT_PROATV_CMD_OPEN_CHANNEL, open_channel);
5521                 }
5522
5523                 g_free(tr);
5524
5525                 return TRUE;
5526         } break;
5527
5528         case USER_CONFIRM_NO_OR_CANCEL:
5529         case USER_CONFIRM_END:
5530                 tr->terminal_rsp_data.open_channel.result_type = RESULT_USER_DID_NOT_ACCEPT_CALL_SETUP_REQ;
5531                 break;
5532         default:
5533                 tr->terminal_rsp_data.open_channel.result_type = RESULT_NO_RESPONSE_FROM_USER;
5534                 break;
5535         }
5536
5537         memcpy((void*)&tr->terminal_rsp_data.open_channel.bearer_desc, &q_data.cmd_data.open_channel.bearer_desc, sizeof(struct tel_sat_bearer_description));
5538         memcpy((void*)&tr->terminal_rsp_data.open_channel.buffer_size, &q_data.cmd_data.open_channel.buffer_size, sizeof(struct tel_sat_buffer_size));
5539
5540         result = TRUE;
5541         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
5542         if (rv != TCORE_RETURN_SUCCESS) {
5543                 dbg("fail to send terminal response");
5544                 result = FALSE;
5545         }
5546 Exit:
5547         g_free(tr);
5548         return result;
5549 }
5550 #else
5551 static gboolean _sat_manager_handle_open_channel_confirm(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gint confirm_type, GVariant *addtional_data)
5552 {
5553         TReturn rv = TCORE_RETURN_FAILURE;
5554         gboolean result = FALSE;
5555
5556         struct treq_sat_user_confirmation_data *conf_data;
5557         struct sat_manager_queue_data q_data;
5558
5559         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
5560
5561         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
5562                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
5563                 return result;
5564         }
5565
5566         if (!plg) {
5567                 dbg("there is no valid plugin at this point");
5568                 return result;
5569         }
5570
5571         conf_data = (struct treq_sat_user_confirmation_data *)calloc(1, sizeof(struct treq_sat_user_confirmation_data));
5572         if (!conf_data)
5573                 return result;
5574
5575         dbg("confirm_type[%d]", confirm_type);
5576
5577         switch (confirm_type) {
5578         case USER_CONFIRM_YES:
5579         case USER_CONFIRM_NO_OR_CANCEL:
5580         case USER_CONFIRM_END:
5581                 conf_data->user_conf = confirm_type;
5582                 break;
5583         default:
5584                 dbg("Not handled confirm type!");
5585                 break;
5586         }
5587         result = TRUE;
5588         rv = sat_manager_send_user_confirmation(ctx->comm, plg, conf_data);
5589         if (rv != TCORE_RETURN_SUCCESS) {
5590                 dbg("fail to send user confirmation message");
5591                 result = FALSE;
5592         }
5593         g_free(conf_data);
5594         return result;
5595 }
5596 #endif
5597 gboolean sat_manager_handle_user_confirm(struct custom_data *ctx, TcorePlugin *plg, GVariant *user_confirm_data)
5598 {
5599         gboolean rv = FALSE;
5600         gboolean result = FALSE;
5601         struct sat_manager_queue_data q_data;
5602
5603         gint command_id, command_type, confirm_type;
5604         GVariant *additional_data = NULL;
5605
5606         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
5607
5608         dbg("user_confirm_data type_format(%s)", g_variant_get_type_string(user_confirm_data));
5609         g_variant_get(user_confirm_data, "(iiv)", &command_id, &confirm_type, &additional_data);
5610
5611         dbg("[SAT] user confirm data command id(%d), confirm_type(%d)", command_id, confirm_type);
5612
5613         rv = sat_manager_queue_peek_data_by_id(ctx, &q_data, command_id);
5614         if (!rv) {
5615                 dbg("[SAT] no commands in queue");
5616                 return result;
5617         }
5618
5619         command_type = (gint)q_data.cmd_type;
5620         dbg("[SAT] command type(%d)", command_type);
5621
5622         switch (command_type) {
5623         case SAT_PROATV_CMD_SELECT_ITEM:
5624                 result = _sat_manager_handle_menu_select_confirm(ctx, plg, command_id, confirm_type, additional_data);
5625                 break;
5626         case SAT_PROATV_CMD_DISPLAY_TEXT:
5627                 result = _sat_manager_handle_display_text_confirm(ctx, plg, command_id, confirm_type, additional_data);
5628                 break;
5629         case SAT_PROATV_CMD_GET_INKEY:
5630                 result = _sat_manager_handle_get_inkey_confirm(ctx, plg, command_id, confirm_type, additional_data);
5631                 break;
5632         case SAT_PROATV_CMD_GET_INPUT:
5633                 result = _sat_manager_handle_get_input_confirm(ctx, plg, command_id, confirm_type, additional_data);
5634                 break;
5635         case SAT_PROATV_CMD_SETUP_CALL:
5636                 result = _sat_manager_handle_setup_call_confirm(ctx, plg, command_id, confirm_type, additional_data);
5637                 break;
5638         case SAT_PROATV_CMD_SEND_DTMF:
5639                 result = _sat_manager_handle_send_dtmf_confirm(ctx, plg, command_id, confirm_type, additional_data);
5640                 break;
5641         case SAT_PROATV_CMD_LAUNCH_BROWSER:
5642                 result = _sat_manager_handle_launch_browser_confirm(ctx, plg, command_id, confirm_type, additional_data);
5643                 break;
5644         case SAT_PROATV_CMD_OPEN_CHANNEL:
5645                 result = _sat_manager_handle_open_channel_confirm(ctx, plg, command_id, confirm_type, additional_data);
5646                 break;
5647         default:
5648                 dbg("[SAT] cannot handle user confirm command(0x%x)", command_type);
5649                 break;
5650         }
5651
5652         return result;
5653 }
5654
5655 static gboolean _sat_manager_handle_play_tone_ui_display_status(struct custom_data *ctx,
5656         TcorePlugin *plg, struct sat_manager_queue_data *q_data, gboolean display_status)
5657 {
5658         char *path;
5659         TelephonySAT *sat;
5660         TelephonyObjectSkeleton *object;
5661
5662         const gchar *cp_name;
5663         GVariant *play_tone = NULL;
5664
5665
5666         gint command_id, tone_type, duration;
5667         gint text_len;
5668         gchar* text;
5669 #if defined(TIZEN_SUPPORT_SAT_ICON)
5670         GVariant *icon_id;
5671 #endif
5672         if (!display_status) {
5673                 struct treq_sat_terminal_rsp_data *tr = NULL;
5674                 dbg("[SAT] fail to show ui display for play tone");
5675
5676                 tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
5677                 if (!tr)
5678                         return FALSE;
5679
5680                 tr->cmd_number = q_data->cmd_data.play_tone.command_detail.cmd_num;
5681                 tr->cmd_type = q_data->cmd_data.play_tone.command_detail.cmd_type;
5682                 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));
5683
5684                 tr->terminal_rsp_data.play_tone.device_id.src = DEVICE_ID_ME;
5685                 tr->terminal_rsp_data.play_tone.device_id.dest = q_data->cmd_data.play_tone.device_id.src;
5686                 tr->terminal_rsp_data.play_tone.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
5687
5688                 sat_manager_send_terminal_response(ctx->comm, plg, tr);
5689                 free(tr);
5690
5691                 return TRUE;
5692         }
5693
5694         /* emit play tone signal */
5695         cp_name = tcore_server_get_cp_name_by_plugin(plg);
5696         if (cp_name == NULL) {
5697                 err("CP name is NULL");
5698                 return FALSE;
5699         }
5700
5701         dbg("CP Name: [%s]", cp_name);
5702         path = g_strdup_printf("%s/%s", MY_DBUS_PATH, cp_name);
5703
5704         /* Look-up Hash table for Object */
5705         object = g_hash_table_lookup(ctx->objects, path);
5706         dbg("Path: [%s] Interface object: [%p]", path, object);
5707         g_free(path);
5708         if (object == NULL) {
5709                 err("Object is NOT defined!!!");
5710                 return FALSE;
5711         }
5712         sat = telephony_object_peek_sat(TELEPHONY_OBJECT(object));
5713
5714         play_tone = sat_manager_play_tone_noti(ctx, cp_name, &q_data->cmd_data.play_tone);
5715
5716         dbg("play tone type_format(%s)", g_variant_get_type_string(play_tone));
5717 #if defined(TIZEN_SUPPORT_SAT_ICON)
5718         g_variant_get(play_tone, "(isi@vii)", &command_id, &text, &text_len, &icon_id, &tone_type, &duration);
5719
5720         telephony_sat_emit_play_tone(sat, command_id, text, text_len, icon_id, tone_type, duration);
5721 #else
5722         g_variant_get(play_tone, "(isiii)", &command_id, &text, &text_len, &tone_type, &duration);
5723
5724         telephony_sat_emit_play_tone(sat, command_id, text, text_len, tone_type, duration);
5725 #endif
5726         g_free(text);
5727
5728         return TRUE;
5729 }
5730
5731 static gboolean _sat_manager_handle_setup_idle_mode_text_ui_display_status(struct custom_data *ctx,
5732         TcorePlugin *plg, struct sat_manager_queue_data *q_data, gboolean display_status)
5733 {
5734         TReturn rv = TCORE_RETURN_FAILURE;
5735         gboolean result = FALSE;
5736
5737         struct treq_sat_terminal_rsp_data *tr;
5738
5739         if (!plg) {
5740                 dbg("there is no valid plugin at this point");
5741                 return result;
5742         }
5743
5744         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
5745         if (!tr)
5746                 return result;
5747
5748         tr->cmd_number = q_data->cmd_data.idle_mode.command_detail.cmd_num;
5749         tr->cmd_type = q_data->cmd_data.idle_mode.command_detail.cmd_type;
5750         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));
5751         tr->terminal_rsp_data.setup_idle_mode_text.device_id.src = q_data->cmd_data.idle_mode.device_id.dest;
5752         tr->terminal_rsp_data.setup_idle_mode_text.device_id.dest = q_data->cmd_data.idle_mode.device_id.src;
5753
5754         tr->terminal_rsp_data.setup_idle_mode_text.result_type = RESULT_SUCCESS;
5755         if (q_data->cmd_data.idle_mode.icon_id.is_exist) {
5756 #if defined(TIZEN_SUPPORT_SAT_ICON)
5757                 tr->terminal_rsp_data.setup_idle_mode_text.result_type = RESULT_SUCCESS;
5758 #else
5759                 tr->terminal_rsp_data.setup_idle_mode_text.result_type = RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME;
5760 #endif
5761         }
5762
5763         /* fail to display text */
5764         if (!display_status) {
5765                 dbg("[SAT] fail to show ui display for setup_idle_mode_text");
5766                 tr->terminal_rsp_data.setup_idle_mode_text.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
5767         }
5768
5769         result = TRUE;
5770         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
5771         if (rv != TCORE_RETURN_SUCCESS) {
5772                 dbg("fail to send terminal response");
5773                 result = FALSE;
5774         }
5775         g_free(tr);
5776
5777         return result;
5778 }
5779
5780 static gboolean _sat_manager_handle_refresh_ui_display_status(struct custom_data *ctx,
5781         TcorePlugin *plg, struct sat_manager_queue_data *q_data, gboolean display_status)
5782 {
5783         struct treq_sat_terminal_rsp_data tr;
5784
5785         memset(&tr, 0, sizeof(struct treq_sat_terminal_rsp_data));
5786
5787         tr.cmd_number = q_data->cmd_data.refresh.command_detail.cmd_num;
5788         tr.cmd_type = q_data->cmd_data.refresh.command_detail.cmd_type;
5789         memcpy((void*)&tr.terminal_rsp_data.refresh.command_detail, &q_data->cmd_data.refresh.command_detail, sizeof(struct tel_sat_cmd_detail_info));
5790         tr.terminal_rsp_data.refresh.device_id.src = q_data->cmd_data.refresh.device_id.dest;
5791         tr.terminal_rsp_data.refresh.device_id.dest = q_data->cmd_data.refresh.device_id.src;
5792
5793         if (!display_status) {
5794                 dbg("fail to show ui for refresh");
5795                 tr.terminal_rsp_data.refresh.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
5796         } else {
5797                 dbg("success to show ui for refresh");
5798                 tr.terminal_rsp_data.refresh.result_type = RESULT_SUCCESS;
5799                 tr.terminal_rsp_data.refresh.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
5800         }
5801
5802         dbg("send refresh tr");
5803         sat_manager_send_terminal_response(ctx->comm, plg, &tr);
5804         return TRUE;
5805 }
5806
5807
5808 #if !defined(TIZEN_PLATFORM_USE_QCOM_QMI)
5809 static gboolean _sat_manager_handle_send_sms_ui_display_status(struct custom_data *ctx,
5810         TcorePlugin *plg, struct sat_manager_queue_data *q_data, gboolean display_status)
5811 {
5812         char *path;
5813         TelephonySAT *sat;
5814         TelephonyObjectSkeleton *object;
5815
5816         const char *cp_name;
5817         GVariant *send_sms = NULL;
5818
5819         gint command_id, ton, npi, tpdu_type;
5820         gboolean b_packing_required;
5821         gint text_len, number_len, tpdu_data_len;
5822         gchar* text, *dialling_number;
5823         GVariant *tpdu_data;
5824 #if defined(TIZEN_SUPPORT_SAT_ICON)
5825         GVariant *icon_id;
5826 #endif
5827
5828         if (!display_status) {
5829                 struct treq_sat_terminal_rsp_data *tr = NULL;
5830                 dbg("[SAT] fail to show ui display for send sms");
5831
5832                 tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
5833                 if (!tr)
5834                         return FALSE;
5835
5836                 tr->cmd_number = q_data->cmd_data.sendSMSInd.command_detail.cmd_num;
5837                 tr->cmd_type = q_data->cmd_data.sendSMSInd.command_detail.cmd_type;
5838                 memcpy((void*)&tr->terminal_rsp_data.send_sms.command_detail, &q_data->cmd_data.sendSMSInd.command_detail, sizeof(struct tel_sat_cmd_detail_info));
5839
5840                 tr->terminal_rsp_data.send_sms.device_id.src = DEVICE_ID_ME;
5841                 tr->terminal_rsp_data.send_sms.device_id.dest = q_data->cmd_data.sendSMSInd.device_id.src;
5842                 tr->terminal_rsp_data.send_sms.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
5843
5844                 sat_manager_send_terminal_response(ctx->comm, plg, tr);
5845                 free(tr);
5846
5847                 return TRUE;
5848         }
5849
5850         /* emit send sms signal */
5851         cp_name = tcore_server_get_cp_name_by_plugin(plg);
5852         if (cp_name == NULL) {
5853                 err("CP name is NULL");
5854                 return FALSE;
5855         }
5856
5857         dbg("CP Name: [%s]", cp_name);
5858         path = g_strdup_printf("%s/%s", MY_DBUS_PATH, cp_name);
5859
5860         /* Look-up Hash table for Object */
5861         object = g_hash_table_lookup(ctx->objects, path);
5862         dbg("Path: [%s] Interface object: [%p]", path, object);
5863         g_free(path);
5864         if (object == NULL) {
5865                 err("Object is NOT defined!!!");
5866                 return FALSE;
5867         }
5868         sat = telephony_object_peek_sat(TELEPHONY_OBJECT(object));
5869
5870         send_sms = sat_manager_send_sms_noti(ctx, cp_name, &q_data->cmd_data.sendSMSInd);
5871
5872         dbg("send sms type_format(%s)", g_variant_get_type_string(send_sms));
5873 #if defined(TIZEN_SUPPORT_SAT_ICON)
5874         g_variant_get(send_sms, "(isi@vbiisii@vi)", &command_id, &text, &text_len, &icon_id, &b_packing_required, &ton, &npi,
5875                         &dialling_number, &number_len, &tpdu_type, &tpdu_data, &tpdu_data_len);
5876 #else
5877         g_variant_get(send_sms, "(isibiisii@vi)", &command_id, &text, &text_len, &b_packing_required, &ton, &npi,
5878                         &dialling_number, &number_len, &tpdu_type, &tpdu_data, &tpdu_data_len);
5879 #endif
5880         telephony_sat_emit_send_sms(sat, command_id, text, text_len, b_packing_required,
5881                         ton, npi, dialling_number, number_len, tpdu_type, tpdu_data, tpdu_data_len);
5882
5883         g_free(text);
5884         g_free(dialling_number);
5885         return TRUE;
5886 }
5887
5888 static gboolean _sat_manager_handle_send_ss_ui_display_status(struct custom_data *ctx,
5889         TcorePlugin *plg, struct sat_manager_queue_data *q_data, gboolean display_status)
5890 {
5891         char *path;
5892         TelephonySAT *sat;
5893         TelephonyObjectSkeleton *object;
5894
5895         const gchar *cp_name;
5896         GVariant *send_ss = NULL;
5897
5898         gint command_id, ton, npi;
5899         gint text_len, ss_str_len;
5900         gchar* text = NULL, *ss_string = NULL;
5901 #if defined(TIZEN_SUPPORT_SAT_ICON)
5902         GVariant *icon_id;
5903 #endif
5904         enum dbus_tapi_sim_slot_id slot_id;
5905
5906         if (!display_status) {
5907                 struct treq_sat_terminal_rsp_data *tr = NULL;
5908                 dbg("[SAT] fail to show ui display for send ss");
5909
5910                 tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
5911                 if (!tr)
5912                         return FALSE;
5913
5914                 tr->cmd_number = q_data->cmd_data.send_ss.command_detail.cmd_num;
5915                 tr->cmd_type = q_data->cmd_data.send_ss.command_detail.cmd_type;
5916                 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));
5917
5918                 tr->terminal_rsp_data.send_ss.device_id.src = DEVICE_ID_ME;
5919                 tr->terminal_rsp_data.send_ss.device_id.dest = q_data->cmd_data.send_ss.device_id.src;
5920                 tr->terminal_rsp_data.send_ss.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
5921
5922                 sat_manager_send_terminal_response(ctx->comm, plg, tr);
5923                 free(tr);
5924
5925                 return TRUE;
5926         }
5927
5928         /* emit send ss signal */
5929         cp_name = tcore_server_get_cp_name_by_plugin(plg);
5930         if (cp_name == NULL) {
5931                 err("CP name is NULL");
5932                 return FALSE;
5933         }
5934
5935         dbg("CP Name: [%s]", cp_name);
5936         path = g_strdup_printf("%s/%s", MY_DBUS_PATH, cp_name);
5937
5938         /* Look-up Hash table for Object */
5939         object = g_hash_table_lookup(ctx->objects, path);
5940         dbg("Path: [%s] Interface object: [%p]", path, object);
5941         g_free(path);
5942         if (object == NULL) {
5943                 err("Object is NOT defined!!!");
5944                 return FALSE;
5945         }
5946         sat = telephony_object_peek_sat(TELEPHONY_OBJECT(object));
5947
5948         send_ss = sat_manager_send_ss_noti(ctx, cp_name, &q_data->cmd_data.send_ss);
5949
5950         dbg("send ss type_format(%s)", g_variant_get_type_string(send_ss));
5951 #if defined(TIZEN_SUPPORT_SAT_ICON)
5952         g_variant_get(send_ss, "(isi@viiis)", &command_id, &text, &text_len, &icon_id,
5953                         &ton, &npi, &ss_str_len, &ss_string);
5954 #else
5955         g_variant_get(send_ss, "(isiiiis)", &command_id, &text, &text_len,
5956                         &ton, &npi, &ss_str_len, &ss_string);
5957 #endif
5958         telephony_sat_emit_send_ss(sat, command_id, text, text_len, ton, npi, ss_string);
5959         g_free(text);
5960         g_free(ss_string);
5961
5962         slot_id = get_sim_slot_id_by_cp_name(tcore_server_get_cp_name_by_plugin(plg));
5963         dbg("slot_id: [%d]", slot_id);
5964         sat_ui_support_launch_ciss_application(SAT_PROATV_CMD_SEND_SS, send_ss, slot_id);
5965
5966         return TRUE;
5967 }
5968
5969 static gboolean _sat_manager_handle_send_ussd_ui_display_status(struct custom_data *ctx,
5970         TcorePlugin *plg, struct sat_manager_queue_data *q_data, gboolean display_status)
5971 {
5972         char *path;
5973         TelephonySAT *sat;
5974         TelephonyObjectSkeleton *object;
5975
5976         const gchar *cp_name;
5977         GVariant *send_ussd = NULL;
5978
5979         gint command_id;
5980         guchar dcs;
5981         gint text_len, ussd_str_len;
5982         gchar* text = NULL, *ussd_string = NULL;
5983 #if defined(TIZEN_SUPPORT_SAT_ICON)
5984         GVariant *icon_id;
5985 #endif
5986         enum dbus_tapi_sim_slot_id slot_id;
5987
5988         if (!display_status) {
5989                 struct treq_sat_terminal_rsp_data *tr = NULL;
5990                 dbg("[SAT] fail to show ui display for send ussd");
5991
5992                 tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
5993                 if (!tr)
5994                         return FALSE;
5995
5996                 tr->cmd_number = q_data->cmd_data.send_ussd.command_detail.cmd_num;
5997                 tr->cmd_type = q_data->cmd_data.send_ussd.command_detail.cmd_type;
5998                 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));
5999
6000                 tr->terminal_rsp_data.send_ussd.device_id.src = DEVICE_ID_ME;
6001                 tr->terminal_rsp_data.send_ussd.device_id.dest = q_data->cmd_data.send_ussd.device_id.src;
6002                 tr->terminal_rsp_data.send_ussd.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
6003
6004                 sat_manager_send_terminal_response(ctx->comm, plg, tr);
6005                 g_free(tr);
6006
6007                 return TRUE;
6008         }
6009
6010         /* emit send ussd signal */
6011         cp_name = tcore_server_get_cp_name_by_plugin(plg);
6012         if (cp_name == NULL) {
6013                 err("CP name is NULL");
6014                 return FALSE;
6015         }
6016
6017         dbg("CP Name: [%s]", cp_name);
6018         path = g_strdup_printf("%s/%s", MY_DBUS_PATH, cp_name);
6019
6020         /* Look-up Hash table for Object */
6021         object = g_hash_table_lookup(ctx->objects, path);
6022         dbg("Path: [%s] Interface object: [%p]", path, object);
6023         g_free(path);
6024         if (object == NULL) {
6025                 err("Object is NOT defined!!!");
6026                 return FALSE;
6027         }
6028         sat = telephony_object_peek_sat(TELEPHONY_OBJECT(object));
6029
6030         send_ussd = sat_manager_send_ussd_noti(ctx, cp_name, &q_data->cmd_data.send_ussd);
6031
6032         dbg("send ussd type_format(%s)", g_variant_get_type_string(send_ussd));
6033 #if defined(TIZEN_SUPPORT_SAT_ICON)
6034         g_variant_get(send_ussd, "(isi@vyis)", &command_id, &text, &text_len, &icon_id, &dcs, &ussd_str_len, &ussd_string);
6035 #else
6036         g_variant_get(send_ussd, "(isiyis)", &command_id, &text, &text_len, &dcs, &ussd_str_len, &ussd_string);
6037 #endif
6038         telephony_sat_emit_setup_ussd(sat, command_id, text, text_len, dcs, ussd_string);
6039         g_free(text);
6040         g_free(ussd_string);
6041
6042         slot_id = get_sim_slot_id_by_cp_name(tcore_server_get_cp_name_by_plugin(plg));
6043         dbg("slot_id: [%d]", slot_id);
6044         sat_ui_support_launch_ciss_application(SAT_PROATV_CMD_SEND_USSD, send_ussd, slot_id);
6045
6046         return TRUE;
6047 }
6048
6049 static gboolean _sat_manager_handle_send_dtmf_ui_display_status(struct custom_data *ctx,
6050         TcorePlugin *plg, struct sat_manager_queue_data *q_data, gboolean display_status)
6051 {
6052         char *path;
6053         TelephonySAT *sat;
6054         TelephonyObjectSkeleton *object;
6055
6056         const gchar *cp_name;
6057
6058         GVariant *send_dtmf = NULL;
6059         gint command_id = 0;
6060         gint text_len = 0, dtmf_str_len = 0;
6061         gchar *text = NULL;
6062         gchar *dtmf_str = NULL;
6063 #if defined(TIZEN_SUPPORT_SAT_ICON)
6064         GVariant *icon_id = NULL;
6065 #endif
6066         if (!display_status) {
6067                 struct treq_sat_terminal_rsp_data *tr = NULL;
6068                 dbg("[SAT] fail to show ui display for send_dtmf");
6069
6070                 tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
6071                 if (!tr)
6072                         return FALSE;
6073
6074                 tr->cmd_number = q_data->cmd_data.send_dtmf.command_detail.cmd_num;
6075                 tr->cmd_type = q_data->cmd_data.send_dtmf.command_detail.cmd_type;
6076                 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));
6077
6078                 tr->terminal_rsp_data.send_dtmf.device_id.src = DEVICE_ID_ME;
6079                 tr->terminal_rsp_data.send_dtmf.device_id.dest = q_data->cmd_data.send_dtmf.device_id.src;
6080                 tr->terminal_rsp_data.send_dtmf.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
6081
6082                 sat_manager_send_terminal_response(ctx->comm, plg, tr);
6083                 g_free(tr);
6084
6085                 return TRUE;
6086         }
6087
6088         /* emit send_dtmf signal */
6089         cp_name = tcore_server_get_cp_name_by_plugin(plg);
6090         if (cp_name == NULL) {
6091                 err("CP name is NULL");
6092                 return FALSE;
6093         }
6094
6095         dbg("CP Name: [%s]", cp_name);
6096         path = g_strdup_printf("%s/%s", MY_DBUS_PATH, cp_name);
6097
6098         /* Look-up Hash table for Object */
6099         object = g_hash_table_lookup(ctx->objects, path);
6100         dbg("Path: [%s] Interface object: [%p]", path, object);
6101         g_free(path);
6102         if (object == NULL) {
6103                 err("Object is NOT defined!!!");
6104                 return FALSE;
6105         }
6106         sat = telephony_object_peek_sat(TELEPHONY_OBJECT(object));
6107
6108         send_dtmf = sat_manager_send_dtmf_noti(ctx, cp_name, &q_data->cmd_data.send_dtmf);
6109
6110         dbg("send_dtmf type_format(%s)", g_variant_get_type_string(send_dtmf));
6111 #if defined(TIZEN_SUPPORT_SAT_ICON)
6112         g_variant_get(send_dtmf, "(isi@vis)", &command_id, &text, &text_len, &icon_id, &dtmf_str_len, &dtmf_str);
6113 #else
6114         g_variant_get(send_dtmf, "(isiis)", &command_id, &text, &text_len, &dtmf_str_len, &dtmf_str);
6115 #endif
6116         telephony_sat_emit_send_dtmf(sat, command_id, text, text_len, dtmf_str, dtmf_str_len);
6117         g_free(text);
6118         g_free(dtmf_str);
6119
6120         return TRUE;
6121 }
6122
6123 static gboolean _sat_manager_handle_open_channel_ui_display_status(struct custom_data *ctx,
6124         TcorePlugin *plg, struct sat_manager_queue_data *q_data, gboolean display_status)
6125 {
6126         char *path;
6127         TelephonyObjectSkeleton *object;
6128
6129         const gchar *cp_name;
6130
6131         GVariant *open_channel = NULL;
6132
6133         gint command_id, bearer_type, protocol_type, dest_addr_type;
6134         gboolean immediate_link, auto_reconnection, bg_mode;
6135         gint text_len, buffer_size, port_number;
6136         gchar *text, *dest_address;
6137         GVariant *bearer_param;
6138         GVariant *bearer_detail;
6139 #if defined(TIZEN_SUPPORT_SAT_ICON)
6140         GVariant *icon_id;
6141 #endif
6142
6143         if (!display_status) {
6144                 struct treq_sat_terminal_rsp_data *tr = NULL;
6145                 dbg("[SAT] fail to show ui display for open channel");
6146
6147                 tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
6148                 if (!tr)
6149                         return FALSE;
6150
6151                 tr->cmd_number = q_data->cmd_data.open_channel.command_detail.cmd_num;
6152                 tr->cmd_type = q_data->cmd_data.open_channel.command_detail.cmd_type;
6153                 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));
6154
6155                 tr->terminal_rsp_data.open_channel.device_id.src = q_data->cmd_data.send_dtmf.device_id.dest;
6156                 tr->terminal_rsp_data.open_channel.device_id.dest = q_data->cmd_data.send_dtmf.device_id.src;
6157                 tr->terminal_rsp_data.open_channel.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
6158
6159                 sat_manager_send_terminal_response(ctx->comm, plg, tr);
6160                 g_free(tr);
6161
6162                 return TRUE;
6163         }
6164
6165         /* emit send_dtmf signal */
6166         cp_name = tcore_server_get_cp_name_by_plugin(plg);
6167         if (cp_name == NULL) {
6168                 err("CP name is NULL");
6169                 return FALSE;
6170         }
6171
6172         dbg("CP Name: [%s]", cp_name);
6173         path = g_strdup_printf("%s/%s", MY_DBUS_PATH, cp_name);
6174
6175         /* Look-up Hash table for Object */
6176         object = g_hash_table_lookup(ctx->objects, path);
6177         dbg("Path: [%s] Interface object: [%p]", path, object);
6178         g_free(path);
6179         if (object == NULL) {
6180                 err("Object is NOT defined!!!");
6181                 return FALSE;
6182         }
6183
6184         open_channel = sat_manager_open_channel_noti(ctx, cp_name, &q_data->cmd_data.open_channel);
6185
6186         dbg("open channel type_format(%s)", g_variant_get_type_string(open_channel));
6187 #if defined(TIZEN_SUPPORT_SAT_ICON)
6188         g_variant_get(open_channel, "(isi@vbbbi@viiiis@v)", &command_id, &text,
6189                 &text_len, &icon_id, &immediate_link, &auto_reconnection, &bg_mode,
6190                 &bearer_type, &bearer_param, &buffer_size, &protocol_type, &port_number,
6191                 &dest_addr_type, &dest_address, &bearer_detail);
6192 #else
6193         g_variant_get(open_channel, "(isibbbi@viiiis@v)", &command_id, &text, &text_len,
6194                 &immediate_link, &auto_reconnection, &bg_mode, &bearer_type, &bearer_param,
6195                 &buffer_size, &protocol_type, &port_number, &dest_addr_type, &dest_address, &bearer_detail);
6196 #endif
6197         /* telephony_sat_emit_open_channel(sat, command_id, text, text_len, immediate_link,
6198                 auto_reconnection, bg_mode, bearer_type, bearer_param, buffer_size,
6199                 protocol_type, port_number, dest_addr_type, dest_address, bearer_detail); */
6200         g_free(text);
6201         g_free(dest_address);
6202
6203         /* BIP Manager */
6204         {
6205                 GDBusConnection *conn = NULL;
6206                 const gchar *g_path = NULL;
6207
6208                 conn = g_dbus_object_manager_server_get_connection(ctx->manager);
6209                 g_path = g_dbus_object_get_object_path(G_DBUS_OBJECT(object));
6210
6211                 sat_ui_support_exec_bip(conn, g_path, SAT_PROATV_CMD_OPEN_CHANNEL, open_channel);
6212         }
6213
6214         return TRUE;
6215 }
6216
6217 gboolean sat_manager_handle_ui_display_status(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gboolean display_status)
6218 {
6219         gboolean result = FALSE;
6220         struct sat_manager_queue_data q_data;
6221
6222         dbg("[SAT] ui display status : command id(%d) display status(%d)", command_id, display_status);
6223         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
6224
6225         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
6226                 dbg("[SAT] command peek data from queue is failed. didn't find in command Q!!");
6227                 return result;
6228         }
6229
6230         if (!plg) {
6231                 dbg("there is no valid plugin at this point");
6232                 return result;
6233         }
6234
6235         switch (q_data.cmd_type) {
6236         case SAT_PROATV_CMD_PLAY_TONE:
6237                 result = _sat_manager_handle_play_tone_ui_display_status(ctx, plg, &q_data, display_status);
6238                 break;
6239         case SAT_PROATV_CMD_SEND_SMS:
6240                 result = _sat_manager_handle_send_sms_ui_display_status(ctx, plg, &q_data, display_status);
6241                 break;
6242         case SAT_PROATV_CMD_SEND_SS:
6243                 result = _sat_manager_handle_send_ss_ui_display_status(ctx, plg, &q_data, display_status);
6244                 break;
6245         case SAT_PROATV_CMD_SEND_USSD:
6246                 result = _sat_manager_handle_send_ussd_ui_display_status(ctx, plg, &q_data, display_status);
6247                 break;
6248         case SAT_PROATV_CMD_SETUP_IDLE_MODE_TEXT:
6249                 result = _sat_manager_handle_setup_idle_mode_text_ui_display_status(ctx, plg, &q_data, display_status);
6250                 break;
6251         case SAT_PROATV_CMD_REFRESH:
6252                 result = _sat_manager_handle_refresh_ui_display_status(ctx, plg, &q_data, display_status);
6253                 break;
6254         case SAT_PROATV_CMD_SEND_DTMF:
6255                 result = _sat_manager_handle_send_dtmf_ui_display_status(ctx, plg, &q_data, display_status);
6256                 break;
6257         case SAT_PROATV_CMD_OPEN_CHANNEL:
6258                 result = _sat_manager_handle_open_channel_ui_display_status(ctx, plg, &q_data, display_status);
6259                 break;
6260         default:
6261                 dbg("[SAT] cannot handle ui display status command(0x%x)", q_data.cmd_type);
6262                 break;
6263         }
6264
6265         return result;
6266 }
6267 #else
6268 static gboolean _sat_manager_handle_open_channel_ui_display_status(struct custom_data *ctx,
6269         TcorePlugin *plg, struct sat_manager_queue_data *q_data, gboolean display_status)
6270 {
6271         TReturn rv = TCORE_RETURN_FAILURE;
6272         gboolean result = FALSE;
6273         struct treq_sat_user_confirmation_data *conf_data;
6274
6275         if (!plg) {
6276                 dbg("there is no valid plugin at this point");
6277                 return result;
6278         }
6279
6280         conf_data = (struct treq_sat_user_confirmation_data *)calloc(1, sizeof(struct treq_sat_user_confirmation_data));
6281         if (!conf_data)
6282                 return result;
6283
6284         dbg("display_status[%d]", display_status);
6285
6286         if (display_status)
6287                 conf_data->user_conf = USER_CONFIRM_YES;
6288         else
6289                 conf_data->user_conf = USER_CONFIRM_NO_OR_CANCEL;
6290
6291         result = TRUE;
6292         rv = sat_manager_send_user_confirmation(ctx->comm, plg, conf_data);
6293         if (rv != TCORE_RETURN_SUCCESS) {
6294                 dbg("fail to send user confirmation message");
6295                 result = FALSE;
6296         }
6297         g_free(conf_data);
6298         return result;
6299 }
6300
6301 gboolean sat_manager_handle_ui_display_status(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gboolean display_status)
6302 {
6303         gboolean result = FALSE;
6304         struct sat_manager_queue_data q_data;
6305
6306         dbg("[SAT] ui display status : command id(%d) display status(%d)", command_id, display_status);
6307         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
6308
6309         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
6310                 dbg("[SAT] command peek data from queue is failed. didn't find in command Q!!");
6311                 return result;
6312         }
6313
6314         if (!plg) {
6315                 dbg("there is no valid plugin at this point");
6316                 return result;
6317         }
6318
6319         switch (q_data.cmd_type) {
6320         case SAT_PROATV_CMD_PLAY_TONE:
6321                 result = _sat_manager_handle_play_tone_ui_display_status(ctx, plg, &q_data, display_status);
6322                 break;
6323         case SAT_PROATV_CMD_SETUP_IDLE_MODE_TEXT:
6324                 result = _sat_manager_handle_setup_idle_mode_text_ui_display_status(ctx, plg, &q_data, display_status);
6325                 break;
6326         case SAT_PROATV_CMD_REFRESH:
6327                 result = _sat_manager_handle_refresh_ui_display_status(ctx, plg, &q_data, display_status);
6328                 break;
6329         case SAT_PROATV_CMD_OPEN_CHANNEL:
6330                 result = _sat_manager_handle_open_channel_ui_display_status(ctx, plg, &q_data, display_status);
6331                 break;
6332         case SAT_PROATV_CMD_SEND_SMS:
6333         case SAT_PROATV_CMD_SEND_SS:
6334         case SAT_PROATV_CMD_SEND_USSD:
6335         case SAT_PROATV_CMD_SEND_DTMF:
6336                 dbg("[SAT] command(0x%x) will be handled by CP", q_data.cmd_type);
6337                 result = TRUE;
6338                 if (q_data.noti_required) {
6339                         TelephonySAT *sat;
6340                         TelephonyObjectSkeleton *object;
6341                         const gchar *cp_name;
6342                         gchar *path = NULL;
6343
6344                         dbg("Noti flag is set, send session end evt.");
6345                         /* emit session end */
6346
6347                         cp_name = tcore_server_get_cp_name_by_plugin(plg);
6348                         if (cp_name == NULL) {
6349                                 err("CP name is NULL");
6350                                 return FALSE;
6351                         }
6352
6353                         dbg("CP Name: [%s]", cp_name);
6354                         path = g_strdup_printf("%s/%s", MY_DBUS_PATH, cp_name);
6355
6356                         /* Look-up Hash table for Object */
6357                         object = g_hash_table_lookup(ctx->objects, path);
6358                         dbg("Path: [%s] Interface object: [%p]", path, object);
6359                         g_free(path);
6360                         if (object == NULL) {
6361                                 err("Object is NOT defined!!!");
6362                                 return FALSE;
6363                         }
6364
6365                         sat = telephony_object_peek_sat(TELEPHONY_OBJECT(object));
6366                         telephony_sat_emit_end_proactive_session(sat, SAT_PROATV_CMD_TYPE_END_PROACTIVE_SESSION);
6367                 }
6368                 break;
6369         default:
6370                 dbg("[SAT] cannot handle ui display status command(0x%x)", q_data.cmd_type);
6371                 break;
6372         }
6373         return result;
6374 }
6375
6376 #endif
6377 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)
6378 {
6379         gboolean rv = FALSE;
6380         GVariant *data = NULL;
6381
6382         dbg("download data type_format(%s)", g_variant_get_type_string(download_data));
6383         g_variant_get(download_data, "v", &data);
6384
6385         if (event_type >= SAT_EVENT_DOWNLOAD_MAX) {
6386                 err("(%d) event number exceeds max count", event_type);
6387                 return FALSE;
6388         }
6389
6390         if (g_evt_list[event_type] == TRUE) {
6391                 dbg("event (%d) shoud be passed to sim", event_type);
6392                 rv = TRUE;
6393         }
6394
6395         if (!rv) {
6396                 dbg("(%d) event does not requested by sim", event_type);
6397                 return FALSE;
6398         }
6399
6400         switch (event_type) {
6401         case EVENT_USER_ACTIVITY:
6402                 dbg("data type_format(%s)", g_variant_get_type_string(data));
6403                 evt_download->device_identitie.src = src_dev;
6404                 evt_download->device_identitie.dest = dest_dev;
6405                 break;
6406         case EVENT_IDLE_SCREEN_AVAILABLE:
6407                 dbg("data type_format(%s)", g_variant_get_type_string(data));
6408                 g_variant_get(data, "(b)", &evt_download->idle_screen);
6409                 evt_download->device_identitie.src = DEVICE_ID_DISPLAY;
6410                 evt_download->device_identitie.dest = dest_dev;
6411                 dbg("idle screen available (%d)", evt_download->idle_screen);
6412                 break;
6413         case EVENT_LANGUAGE_SELECTION:
6414                 dbg("data type_format(%s)", g_variant_get_type_string(data));
6415                 g_variant_get(data, "(i)", &evt_download->language);
6416                 evt_download->device_identitie.src = src_dev;
6417                 evt_download->device_identitie.dest = dest_dev;
6418                 dbg("selected language (%d)", evt_download->language);
6419                 break;
6420         case EVENT_BROWSER_TERMINATION: {
6421                 dbg("data type_format(%s)", g_variant_get_type_string(data));
6422                 g_variant_get(data, "(i)", &evt_download->browser_termination);
6423                 evt_download->device_identitie.src = src_dev;
6424                 evt_download->device_identitie.dest = dest_dev;
6425                 dbg("browser termination cause(%d)", evt_download->browser_termination);
6426         } break;
6427         case EVENT_DATA_AVAILABLE: {
6428                 guchar channel_id, channel_data_len;
6429                 gint channel_status, channel_info;
6430
6431                 dbg("data type_format(%s)", g_variant_get_type_string(data));
6432                 g_variant_get(data, "(yiiy)", &channel_id, &channel_status, &channel_info, &channel_data_len);
6433                 evt_download->device_identitie.src = src_dev;
6434                 evt_download->device_identitie.dest = dest_dev;
6435                 evt_download->channel_status.channel_id = channel_id;
6436                 evt_download->channel_status.status = channel_status;
6437                 evt_download->channel_status.status_info = channel_info;
6438                 evt_download->channel_data_len.data_len = channel_data_len;
6439                 dbg("data available channel id (%d)", evt_download->channel_status.channel_id);
6440         } break;
6441         case EVENT_CHANNEL_STATUS: {
6442                 guchar channel_id;
6443                 gint channel_status, channel_info;
6444
6445                 dbg("data type_format(%s)", g_variant_get_type_string(data));
6446                 g_variant_get(data, "(yii)", &channel_id, &channel_status, &channel_info);
6447                 evt_download->device_identitie.src = src_dev;
6448                 evt_download->device_identitie.dest = dest_dev;
6449                 evt_download->channel_status.channel_id = channel_id;
6450                 evt_download->channel_status.status = channel_status;
6451                 evt_download->channel_status.status_info = channel_info;
6452         } break;
6453         default:
6454                 dbg("not support download event (%d)", event_type);
6455                 break;
6456         }
6457
6458         return TRUE;
6459 }
6460
6461 gboolean sat_manager_update_language(struct custom_data *ctx, const char *cp_name, GVariant *language_noti)
6462 {
6463         Server *s = NULL;
6464         TcorePlugin *plg = NULL;
6465         static Storage *strg;
6466
6467         TReturn rv = TCORE_RETURN_FAILURE;
6468         gboolean result = FALSE;
6469         const gchar *lang_str = NULL;
6470         gint command_id, language;
6471         gboolean b_specified;
6472
6473         struct treq_sat_terminal_rsp_data *tr;
6474         struct sat_manager_queue_data q_data;
6475
6476         s = ctx->server;
6477         strg = tcore_server_find_storage(s, "vconf");
6478
6479         plg = tcore_server_find_plugin(ctx->server, cp_name);
6480         if (!plg) {
6481                 dbg("there is no valid plugin at this point");
6482                 return result;
6483         }
6484
6485         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
6486
6487         dbg("language_noti type_format(%s)", g_variant_get_type_string(language_noti));
6488         g_variant_get(language_noti, "(iib)", &command_id, &language, &b_specified);
6489
6490         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
6491                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
6492                 return result;
6493         }
6494
6495         if (q_data.cmd_type != SAT_PROATV_CMD_LANGUAGE_NOTIFICATION) {
6496                 dbg("[SAT] Language Noti dequeue failed. didn't find in command Q!!");
6497                 return result;
6498         }
6499
6500         if (b_specified) {
6501                 lang_str = _convert_sim_lang_to_string((enum tel_sim_language_type)language);
6502                 if (!lang_str)
6503                         dbg("language is not exist");
6504                 dbg("converted lang (%s)", lang_str);
6505
6506                 if (_sat_manager_check_language_set(lang_str)) {
6507                         dbg("supprted language, set vconf.");
6508                         result = tcore_storage_set_string(strg, STORAGE_KEY_LANGUAGE_SET, (const char *)lang_str);
6509                         if (!result)
6510                                 dbg("fail to update language");
6511                 }
6512         }
6513
6514         /* TR should be sent with success result
6515          * regardless of language is specified or not.
6516          */
6517         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
6518         if (!tr)
6519                 return FALSE;
6520
6521         tr->cmd_number = q_data.cmd_data.language_notification.command_detail.cmd_num;
6522         tr->cmd_type = q_data.cmd_data.language_notification.command_detail.cmd_type;
6523         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));
6524         tr->terminal_rsp_data.language_notification.device_id.src = DEVICE_ID_ME;
6525         tr->terminal_rsp_data.language_notification.device_id.dest = DEVICE_ID_SIM;
6526         tr->terminal_rsp_data.language_notification.result_type = RESULT_SUCCESS;
6527
6528         result = TRUE;
6529         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
6530         if (rv != TCORE_RETURN_SUCCESS) {
6531                 dbg("fail to send terminal response");
6532                 g_free(tr);
6533                 result = FALSE;
6534                 return result;
6535         }
6536
6537         g_free(tr);
6538         return result;
6539 }