src/sat_manager.c

   1 /*
   2  * tel-plugin-dbus_tapi
   3  *
   4  * Copyright (c) 2012 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Ja-young Gu <jygu@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */
  20 #include <stdio.h>
  21 #include <string.h>
  22 #include <stdlib.h>
  23 #include <errno.h>
  24 #include <sys/time.h>
  25 #include <glib-object.h>
  26
  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 <type/call.h>
  39 #include <type/sim.h>
  40
  41 #include "generated-code.h"
  42 #include "common.h"
  43 #include "sat_manager.h"
  44 #include "sat_ui_support/sat_ui_support.h"
  45
  46 #define SAT_DEF_CMD_Q_MAX 10
  47 #define SAT_TIME_OUT 30000
  48
  49 static struct sat_manager_queue_data *sat_queue[SAT_DEF_CMD_Q_MAX] = {NULL, };
  50
  51 static unsigned char _convert_decimal_to_bcd(int dec)
  52 {
  53         int tmp1, tmp0;
  54         unsigned char tmp3;
  55
  56         tmp1 = dec/10;
  57         tmp0 = dec - tmp1*10;
  58         tmp3 = tmp0 << 4;
  59         tmp3 += tmp1;
  60
  61         dbg("input decimal(%d), bcd(%d%d), endian(%x)", dec, tmp1, tmp0, tmp3);
  62         return tmp3;
  63 }
  64
  65 static const gchar* _convert_sim_lang_to_string(enum tel_sim_language_type lang)
  66 {
  67         dbg("convert lang(%d)", lang);
  68         switch(lang){
  69                 case SIM_LANG_GERMAN:
  70                         return "de_DE.UTF-8";
  71                 case SIM_LANG_ENGLISH:
  72                         return "en_GB.UTF-8";
  73                 case SIM_LANG_ITALIAN:
  74                         return "it_IT.UTF-8";
  75                 case SIM_LANG_FRENCH:
  76                         return "fr_FR.UTF-8";
  77                 case SIM_LANG_SPANISH:
  78                         return "es_ES.UTF-8";
  79                 case SIM_LANG_DUTCH:
  80                         return "nl_NL.UTF-8";
  81                 case SIM_LANG_SWEDISH:
  82                         return "sv_SE.UTF-8";
  83                 case SIM_LANG_DANISH:
  84                         return "da_DK.UTF-8";
  85                 case SIM_LANG_PORTUGUESE:
  86                         return "pt_PT.UTF-8";
  87                 case SIM_LANG_FINNISH:
  88                         return "fi_FI.UTF-8";
  89                 case SIM_LANG_NORWEGIAN:
  90                         return "nb_NO.UTF-8";
  91                 case SIM_LANG_GREEK:
  92                         return "el_GR.UTF-8";
  93                 case SIM_LANG_TURKISH:
  94                         return "tr_TR.UTF-8";
  95                 case SIM_LANG_HUNGARIAN:
  96                         return "hu_HU.UTF-8";
  97                 case SIM_LANG_POLISH:
  98                         return "pl_PL.UTF-8";
  99                 case SIM_LANG_KOREAN:
 100                         return "ko_KR.UTF-8";
 101                 case SIM_LANG_CHINESE:
 102                         return "zh_CH.UTF-8";
 103                 case SIM_LANG_RUSSIAN:
 104                         return "ru_RU.UTF-8";
 105                 case SIM_LANG_JAPANESE:
 106                         return "ja_JP.UTF-8";
 107                 default:
 108                         return NULL;
 109         }//end of switch
 110
 111         return NULL;
 112 }
 113
 114 static enum tel_sim_language_type _convert_string_to_sim_lang(const gchar* lang_str)
 115 {
 116         dbg("convert lang(%s)", lang_str);
 117
 118         if (g_str_equal(lang_str, "de_DE.UTF-8") == TRUE) {
 119                 return SIM_LANG_GERMAN;
 120         }
 121         else if (g_str_equal(lang_str, "en_GB.UTF-8") == TRUE) {
 122                 return SIM_LANG_ENGLISH;
 123         }
 124         else if (g_str_equal(lang_str, "it_IT.UTF-8") == TRUE) {
 125                 return SIM_LANG_ITALIAN;
 126         }
 127         else if (g_str_equal(lang_str, "fr_FR.UTF-8") == TRUE) {
 128                 return SIM_LANG_FRENCH;
 129         }
 130         else if (g_str_equal(lang_str, "es_ES.UTF-8") == TRUE) {
 131                 return SIM_LANG_SPANISH;
 132         }
 133         else if (g_str_equal(lang_str, "nl_NL.UTF-8") == TRUE) {
 134                 return SIM_LANG_DUTCH;
 135         }
 136         else if (g_str_equal(lang_str, "sv_SE.UTF-8") == TRUE) {
 137                 return SIM_LANG_SWEDISH;
 138         }
 139         else if (g_str_equal(lang_str, "da_DK.UTF-8") == TRUE) {
 140                 return SIM_LANG_DANISH;
 141         }
 142         else if (g_str_equal(lang_str, "pt_PT.UTF-8") == TRUE) {
 143                 return SIM_LANG_PORTUGUESE;
 144         }
 145         else if (g_str_equal(lang_str, "fi_FI.UTF-8") == TRUE) {
 146                 return SIM_LANG_FINNISH;
 147         }
 148         else if (g_str_equal(lang_str, "nb_NO.UTF-8") == TRUE) {
 149                 return SIM_LANG_NORWEGIAN;
 150         }
 151         else if (g_str_equal(lang_str, "el_GR.UTF-8") == TRUE) {
 152                 return SIM_LANG_GREEK;
 153         }
 154         else if (g_str_equal(lang_str, "tr_TR.UTF-8") == TRUE) {
 155                 return SIM_LANG_TURKISH;
 156         }
 157         else if (g_str_equal(lang_str, "hu_HU.UTF-8") == TRUE) {
 158                 return SIM_LANG_HUNGARIAN;
 159         }
 160         else if (g_str_equal(lang_str, "pl_PL.UTF-8") == TRUE) {
 161                 return SIM_LANG_POLISH;
 162         }
 163         else if (g_str_equal(lang_str, "ko_KR.UTF-8") == TRUE) {
 164                 return SIM_LANG_KOREAN;
 165         }
 166         else if (g_str_equal(lang_str, "zh_CH.UTF-8") == TRUE) {
 167                 return SIM_LANG_CHINESE;
 168         }
 169         else if (g_str_equal(lang_str, "ru_RU.UTF-8") == TRUE) {
 170                 return SIM_LANG_RUSSIAN;
 171         }
 172         else if (g_str_equal(lang_str, "ja_JP.UTF-8") == TRUE) {
 173                 return SIM_LANG_JAPANESE;
 174         }
 175
 176         dbg("there is no matched language");
 177         return SIM_LANG_UNSPECIFIED;
 178 }
 179
 180 static unsigned int _get_time_in_ms(struct tel_sat_duration *dr)
 181 {
 182         switch (dr->time_unit) {
 183                 case TIME_UNIT_MINUTES:
 184                         return (unsigned int)dr->time_interval * 60000;
 185                         break;
 186
 187                 case TIME_UNIT_SECONDS:
 188                         return (unsigned int)dr->time_interval * 1000;
 189                         break;
 190
 191                 case TIME_UNIT_TENTHS_OF_SECONDS:
 192                         return (unsigned int)dr->time_interval * 100;
 193                         break;
 194
 195                 case TIME_UNIT_RESERVED:
 196                 default:
 197                         return 0;       // set default
 198                         break;
 199         }
 200
 201         return 0;
 202 }
 203
 204 static int _get_queue_empty_index(void)
 205 {
 206         int cnt = 0;
 207         int i;
 208         int index = -1;
 209
 210         for(i =0; i<SAT_DEF_CMD_Q_MAX ; i++) {
 211                 if(sat_queue[i]) {
 212                         dbg("index[%d] is being used",i);
 213                         cnt++;
 214                 }
 215         }
 216         for(i =0; i<SAT_DEF_CMD_Q_MAX ; i++) {
 217                 if(!sat_queue[i]) {
 218                         dbg("found empty slot [%p] at index [%d]", sat_queue[i] ,i);
 219                         index = i;
 220                         break;
 221                 }
 222         }
 223         dbg("[SAT]SAT Command Queue current length [%d], MAX [%d]. \n", cnt, SAT_DEF_CMD_Q_MAX);
 224         return index;
 225 }
 226
 227 static gboolean _push_data(struct custom_data *ctx, struct sat_manager_queue_data *cmd_obj)
 228 {
 229         struct sat_manager_queue_data *item;
 230         int index = cmd_obj->cmd_id;
 231
 232         if (sat_queue[index]) {
 233                 dbg("[SAT] sat_queue[%d] is not null [%p].\n", sat_queue[index]);
 234                 return FALSE;
 235         }
 236
 237         item = g_new0(struct sat_manager_queue_data, 1);
 238
 239         if(!item) {
 240                 dbg("[SAT] FAILED TO ALLOC QUEUE ITEM!\n");
 241                 return FALSE;
 242         }
 243
 244         memcpy((void*)item, (void*)cmd_obj, sizeof(struct sat_manager_queue_data));
 245         sat_queue[index] = item;
 246         dbg("push data to queue at index[%d], [%p].\n",index, item);
 247         return TRUE;
 248 }
 249
 250 static gboolean _pop_nth_data(struct custom_data *ctx, struct sat_manager_queue_data *cmd_obj, int command_id)
 251 {
 252         struct sat_manager_queue_data *item;
 253         int index = command_id;
 254
 255         if(!sat_queue[index]) {
 256                 dbg("[SAT] sat_queue[%d] is null !!\n", index);
 257                 return FALSE;
 258         }
 259
 260         item = sat_queue[index];
 261
 262         memcpy((void*)cmd_obj, (void*)item, sizeof(struct sat_manager_queue_data));
 263         dbg("pop data from queue at index[%d],[%p].\n",index, item);
 264         sat_queue[index] = NULL;
 265         g_free(item);
 266         return TRUE;
 267 }
 268
 269 static gboolean _peek_nth_data(struct custom_data *ctx, struct sat_manager_queue_data *cmd_obj, int command_id)
 270 {
 271         struct sat_manager_queue_data *item = NULL;
 272
 273         int index = command_id;
 274
 275         if(!sat_queue[index]) {
 276                 dbg("[SAT] sat_queue[%d] is null !!\n", index);
 277                 return FALSE;
 278         }
 279
 280         item = sat_queue[index];
 281         memcpy((void*)cmd_obj, (void*)item, sizeof(struct sat_manager_queue_data));
 282         dbg("peek data from queue at index[%d],[%p].\n",index, item);
 283         return TRUE;
 284 }
 285
 286 void sat_manager_init_queue(struct custom_data *ctx)
 287 {
 288         int i;
 289         dbg("Enter");
 290         for(i=0;i<SAT_DEF_CMD_Q_MAX;i++) {
 291                 sat_queue[i] = NULL;
 292         }
 293 }
 294
 295 static gboolean sat_manager_enqueue_cmd(struct custom_data *ctx, struct sat_manager_queue_data *cmd_obj)
 296 {
 297         int id;
 298
 299         id = _get_queue_empty_index();
 300         if(id < 0) {
 301                 dbg("Fail to get empty index.\n");
 302                 return FALSE;
 303         }
 304         cmd_obj->cmd_id = id;
 305         return _push_data(ctx, cmd_obj);
 306 }
 307
 308 static gboolean sat_manager_dequeue_cmd_by_id(struct custom_data *ctx, struct sat_manager_queue_data *cmd_obj, int cmd_id)
 309 {
 310         return _pop_nth_data(ctx, cmd_obj, cmd_id);
 311 }
 312
 313 static gboolean sat_manager_queue_peek_data_by_id(struct custom_data *ctx, struct sat_manager_queue_data *cmd_obj, int command_id)
 314 {
 315         return _peek_nth_data(ctx, cmd_obj, command_id);
 316 }
 317
 318 static gboolean sat_manager_check_availiable_event_list(struct tel_sat_setup_event_list_tlv *event_list_tlv)
 319 {
 320         gboolean rv = TRUE;
 321         int index = 0;
 322
 323         for(index = 0; index < event_list_tlv->event_list.event_list_cnt; index++){
 324                 if(event_list_tlv->event_list.evt_list[index] == EVENT_USER_ACTIVITY){
 325                         dbg("do user activity");
 326                 }
 327                 else if(event_list_tlv->event_list.evt_list[index] == EVENT_IDLE_SCREEN_AVAILABLE){
 328                         dbg("do idle screen");
 329                 }
 330                 else if(event_list_tlv->event_list.evt_list[index] == EVENT_LANGUAGE_SELECTION){
 331                         dbg("do language selection");
 332                 }
 333                 else if(event_list_tlv->event_list.evt_list[index] == EVENT_BROWSER_TERMINATION){
 334                         dbg("do browser termination");
 335                 }
 336                 else if(event_list_tlv->event_list.evt_list[index] == EVENT_DATA_AVAILABLE){
 337                         dbg("do data available (bip)");
 338                 }
 339                 else if(event_list_tlv->event_list.evt_list[index] == EVENT_CHANNEL_STATUS){
 340                         dbg("do channel status (bip)");
 341                 }
 342                 else{
 343                         dbg("unmanaged event (%d)", event_list_tlv->event_list.evt_list[index]);
 344                         rv = FALSE;
 345                 }
 346         }
 347
 348         return rv;
 349 }
 350
 351 static TReturn sat_manager_send_terminal_response(Communicator *comm, TcorePlugin *target_plg, struct treq_sat_terminal_rsp_data *tr)
 352 {
 353         TReturn rv = TCORE_RETURN_SUCCESS;
 354         UserRequest *ur = NULL;
 355
 356         ur = tcore_user_request_new(comm, tcore_server_get_cp_name_by_plugin(target_plg));
 357         if (!ur) {
 358                 dbg("ur is NULL");
 359                 return TCORE_RETURN_FAILURE;
 360         }
 361
 362         tcore_user_request_set_command(ur, TREQ_SAT_REQ_TERMINALRESPONSE);
 363         tcore_user_request_set_data(ur, sizeof(struct treq_sat_terminal_rsp_data), (void *)tr);
 364         rv = tcore_communicator_dispatch_request(comm, ur);
 365         if (rv != TCORE_RETURN_SUCCESS) {
 366                 dbg("fail to send terminal response",rv);
 367                 tcore_user_request_unref(ur);
 368                 rv = TCORE_RETURN_FAILURE;
 369         }
 370
 371         return rv;
 372 }
 373
 374 gboolean sat_manager_remove_cmd_by_id(struct custom_data *ctx, int cmd_id)
 375 {
 376         struct sat_manager_queue_data *item;
 377         int index = cmd_id;
 378
 379         if(!sat_queue[index]) {
 380                 dbg("[SAT] sat_queue[%d] is already null !!\n", index);
 381                 return FALSE;
 382         }
 383         item = sat_queue[index];
 384
 385         dbg("remove data from queue at index[%d],[%p].\n",index, item);
 386         sat_queue[index] = NULL;
 387         g_free(item);
 388         return TRUE;
 389 }
 390
 391 GVariant* sat_manager_caching_setup_menu_info(struct custom_data *ctx, const char *plugin_name, struct tel_sat_setup_menu_tlv* setup_menu_tlv)
 392 {
 393         TcorePlugin *plg = NULL;
 394         GVariant *setup_menu_info = NULL;
 395         struct sat_manager_queue_data q_data;
 396
 397         gint command_id = 0, menu_cnt = 0, title_len =0;
 398         gboolean menu_present = FALSE, help_info = FALSE, updated = FALSE;
 399         gchar main_title[SAT_ALPHA_ID_LEN_MAX];
 400         GVariantBuilder *v_builder = NULL;
 401         GVariant *menu_items = NULL;
 402
 403         dbg("interpreting setup menu notification");
 404         memset(&main_title, 0 , SAT_ALPHA_ID_LEN_MAX);
 405
 406         plg = tcore_server_find_plugin(ctx->server, plugin_name);
 407         if (!plg){
 408                 dbg("there is no valid plugin at this point");
 409                 return NULL;
 410         }
 411
 412         if ((setup_menu_tlv->icon_id.is_exist)
 413                         && (setup_menu_tlv->icon_id.icon_qualifer == ICON_QUALI_NOT_SELF_EXPLANATORY)
 414                         && (!setup_menu_tlv->alpha_id.is_exist || setup_menu_tlv->alpha_id.alpha_data_len == 0)){
 415
 416                 struct treq_sat_terminal_rsp_data *tr = NULL;
 417                 dbg("exceptional case to fix gcf case 2.4 command not understood");
 418
 419                 tr = g_new0(struct treq_sat_terminal_rsp_data, 1);
 420                 tr->cmd_number = setup_menu_tlv->command_detail.cmd_num;
 421                 tr->cmd_type = setup_menu_tlv->command_detail.cmd_type;
 422
 423                 memcpy((void*)&tr->terminal_rsp_data.setup_menu.command_detail, &setup_menu_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
 424                 tr->terminal_rsp_data.setup_menu.device_id.src = setup_menu_tlv->device_id.dest;
 425                 tr->terminal_rsp_data.setup_menu.device_id.dest = setup_menu_tlv->device_id.src;
 426                 tr->terminal_rsp_data.setup_menu.result_type = RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME;
 427
 428                 sat_manager_send_terminal_response(ctx->comm, plg, tr);
 429                 g_free(tr);
 430                 return NULL;
 431         }
 432
 433         //check menu update
 434         if(ctx->cached_sat_main_menu){
 435                 dbg("main menu info is updated");
 436                 updated = TRUE;
 437         }
 438
 439         //menu helpinfo
 440         help_info = setup_menu_tlv->command_detail.cmd_qualifier.setup_menu.help_info;
 441
 442         //menu presence
 443         menu_present = setup_menu_tlv->command_detail.cmd_qualifier.setup_menu.select_preference;
 444
 445         //menu item count
 446         menu_cnt = setup_menu_tlv->menu_item_cnt;
 447
 448         //check the validation of content
 449         if(!menu_cnt || (setup_menu_tlv->menu_item_cnt == 1 && setup_menu_tlv->menu_item[0].text_len == 0)){
 450                 //support GCF case 27.22.4.8.1 - 1.1 setup menu
 451
 452                 struct treq_sat_terminal_rsp_data *tr = NULL;
 453                 dbg("no menu item");
 454
 455                 tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
 456                 tr->cmd_number = setup_menu_tlv->command_detail.cmd_num;
 457                 tr->cmd_type = setup_menu_tlv->command_detail.cmd_type;
 458
 459                 memcpy((void*)&tr->terminal_rsp_data.setup_menu.command_detail, &setup_menu_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
 460                 tr->terminal_rsp_data.setup_menu.device_id.src = setup_menu_tlv->device_id.dest;
 461                 tr->terminal_rsp_data.setup_menu.device_id.dest = setup_menu_tlv->device_id.src;
 462                 tr->terminal_rsp_data.setup_menu.result_type = RESULT_SUCCESS;
 463
 464                 sat_manager_send_terminal_response(ctx->comm, plg, tr);
 465                 g_free(tr);
 466
 467                 return NULL;
 468         }
 469
 470         //get title
 471         if(setup_menu_tlv->alpha_id.alpha_data_len)
 472                 tcore_util_convert_string_to_utf8((unsigned char*)&main_title,(unsigned short *)&title_len,
 473                         setup_menu_tlv->alpha_id.dcs.a_format,
 474                         (unsigned char*)&setup_menu_tlv->alpha_id.alpha_data,
 475                         (unsigned short)setup_menu_tlv->alpha_id.alpha_data_len);
 476         dbg("sat main menu title(%s)",main_title);
 477
 478         v_builder = g_variant_builder_new(G_VARIANT_TYPE ("a(si)"));
 479
 480         //get menu items
 481         if(!setup_menu_tlv->next_act_ind_list.cnt){
 482                 int index = 0;
 483
 484                 dbg("setup_menu_tlv->next_act_ind_list.cnt == 0");
 485
 486                 for(index = 0; index < menu_cnt; index++){
 487                         gint item_len;
 488                         gchar item_str[SAT_ITEM_TEXT_LEN_MAX + 1];
 489
 490                         if(!setup_menu_tlv->alpha_id.alpha_data_len)
 491                                 setup_menu_tlv->alpha_id.dcs.a_format = ALPHABET_FORMAT_8BIT_DATA;
 492
 493                         memset(&item_str, 0 , SAT_ITEM_TEXT_LEN_MAX + 1);
 494                         tcore_util_convert_string_to_utf8((unsigned char*)&item_str, (unsigned short *)&item_len,
 495                                 setup_menu_tlv->alpha_id.dcs.a_format,
 496                                 (unsigned char*)&setup_menu_tlv->menu_item[index].text,
 497                                 (unsigned short)setup_menu_tlv->menu_item[index].text_len);
 498
 499                         dbg( "index(%d) item_id(%d) item_string(%s)", index, setup_menu_tlv->menu_item[index].item_id, item_str);
 500
 501                         //g_variant_builder_add(v_builder, "(sy)", &item_str, setup_menu_tlv->menu_item[index].item_id);
 502                         g_variant_builder_add(v_builder, "(si)", item_str, (gint32)(setup_menu_tlv->menu_item[index].item_id));
 503                 }
 504         }
 505         else{
 506                 int index = 0;
 507
 508                 dbg("setup_menu_tlv->next_act_ind_list.cnt == 0");
 509
 510                 for(index = 0; index < menu_cnt; index++){
 511                         gint item_len;
 512                         gchar item_str[SAT_ITEM_TEXT_LEN_MAX + 1];
 513
 514                         if(setup_menu_tlv->alpha_id.alpha_data_len == 0)
 515                                 setup_menu_tlv->alpha_id.dcs.a_format = ALPHABET_FORMAT_8BIT_DATA;
 516
 517                         memset(&item_str, '\0' , SAT_ITEM_TEXT_LEN_MAX + 1);
 518                         tcore_util_convert_string_to_utf8((unsigned char*)&item_str, (unsigned short *)&item_len,
 519                                 setup_menu_tlv->alpha_id.dcs.a_format,
 520                                 (unsigned char*)&setup_menu_tlv->menu_item[index].text,
 521                                 (unsigned short)setup_menu_tlv->menu_item[index].text_len);
 522
 523                         if( setup_menu_tlv->next_act_ind_list.indicator_list[index] == SAT_PROATV_CMD_SEND_SMS) {
 524                                 g_strlcat(item_str," [Send SMS]", 11);
 525                         }
 526                         else if (setup_menu_tlv->next_act_ind_list.indicator_list[index]== SAT_PROATV_CMD_SETUP_CALL) {
 527                                 g_strlcat(item_str," [Set Up Call]", 14);
 528                         }
 529                         else if (setup_menu_tlv->next_act_ind_list.indicator_list[index]== SAT_PROATV_CMD_LAUNCH_BROWSER){
 530                                 g_strlcat(item_str," [Launch Browser]", 17);
 531                         }
 532                         else if (setup_menu_tlv->next_act_ind_list.indicator_list[index]== SAT_PROATV_CMD_PROVIDE_LOCAL_INFO)   {
 533                                 g_strlcat(item_str," [Provide Terminal Information]", 31);
 534                         }
 535
 536                         dbg( "index(%d) item_id(%d) item_string(%s)", index, setup_menu_tlv->menu_item[index].item_id, item_str);
 537
 538                         //g_variant_builder_add(v_builder, "(sy)", g_strdup(item_str), setup_menu_tlv->menu_item[index].item_id);
 539                         g_variant_builder_add(v_builder, "(si)", item_str, (gint32)(setup_menu_tlv->menu_item[index].item_id));
 540                 }
 541
 542         }
 543         menu_items = g_variant_builder_end(v_builder);
 544
 545         //enqueue data and generate cmd_id
 546         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
 547         q_data.cmd_type = SAT_PROATV_CMD_SETUP_MENU;
 548         memcpy((void*)&(q_data.cmd_data.setupMenuInd), setup_menu_tlv, sizeof(struct tel_sat_setup_menu_tlv));
 549         sat_manager_enqueue_cmd(ctx, &q_data);
 550         command_id = q_data.cmd_id;
 551
 552         setup_menu_info = g_variant_new("(ibsvibb)", command_id, menu_present, main_title, menu_items,
 553                         menu_cnt, help_info, updated);
 554
 555         return setup_menu_info;
 556 }
 557
 558 GVariant* sat_manager_display_text_noti(struct custom_data *ctx, const char *plugin_name, struct tel_sat_display_text_tlv* display_text_tlv)
 559 {
 560         TcorePlugin *plg = NULL;
 561         GVariant *display_text = NULL;
 562         struct sat_manager_queue_data q_data;
 563
 564         gint command_id = 0, text_len =0, duration= 0, tmp_duration = 0;
 565         gboolean immediately_rsp = FALSE, high_priority = FALSE, user_rsp_required = FALSE;
 566         gchar text[SAT_TEXT_STRING_LEN_MAX];
 567         GVariant *icon_id = NULL;
 568
 569         dbg("interpreting display text notification");
 570         memset(&text, 0 , SAT_TEXT_STRING_LEN_MAX);
 571
 572         plg = tcore_server_find_plugin(ctx->server, plugin_name);
 573         if (!plg){
 574                 dbg("there is no valid plugin at this point");
 575                 return NULL;
 576         }
 577
 578         if ( (display_text_tlv->icon_id.is_exist && display_text_tlv->icon_id.icon_qualifer == ICON_QUALI_NOT_SELF_EXPLANATORY)
 579                         || !display_text_tlv->text.string_length ){
 580
 581                 struct treq_sat_terminal_rsp_data *tr = NULL;
 582                 dbg("[SAT]  exceptional case to fix gcf case 2.4 command not understood");
 583
 584                 tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
 585                 tr->cmd_number = display_text_tlv->command_detail.cmd_num;
 586                 tr->cmd_type = display_text_tlv->command_detail.cmd_type;
 587
 588                 memcpy((void*)&tr->terminal_rsp_data.display_text.command_detail, &display_text_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
 589                 tr->terminal_rsp_data.display_text.device_id.src = DEVICE_ID_ME;
 590                 tr->terminal_rsp_data.display_text.device_id.dest = display_text_tlv->device_id.src;
 591                 tr->terminal_rsp_data.display_text.result_type = RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME;
 592
 593                 sat_manager_send_terminal_response(ctx->comm, plg, tr);
 594                 g_free(tr);
 595
 596                 return NULL;
 597         }
 598
 599         //user resp required & time_duration
 600         if(display_text_tlv->command_detail.cmd_qualifier.display_text.text_clear_type == TEXT_WAIT_FOR_USER_TO_CLEAR_MSG){
 601                 user_rsp_required = TRUE;
 602                 duration = SAT_TIME_OUT;
 603         }
 604         else{
 605                 duration = 15000;
 606         }
 607
 608         //immediate response requested
 609         if (display_text_tlv->immediate_response_requested)
 610                 immediately_rsp = TRUE;
 611
 612         //high priority
 613         if (display_text_tlv->command_detail.cmd_qualifier.display_text.text_priority == TEXT_PRIORITY_HIGH)
 614                 high_priority = TRUE;
 615         dbg("user rsp required(%d), immediately rsp(%d) priority(%d)",user_rsp_required, immediately_rsp, high_priority);
 616
 617         //get text
 618         tcore_util_convert_string_to_utf8((unsigned char*) &text, (unsigned short *) &text_len,
 619                         display_text_tlv->text.dcs.a_format,
 620                         (unsigned char*) &display_text_tlv->text.string,
 621                         (unsigned short) display_text_tlv->text.string_length);
 622         dbg("sat display text(%s)",text);
 623
 624         //duration
 625         if(!display_text_tlv->duration.time_interval){
 626                 tmp_duration = _get_time_in_ms(&display_text_tlv->duration);
 627         }
 628
 629         if(tmp_duration > 0)
 630                 duration = tmp_duration;
 631
 632 /*       ETSI TS 102 223 6.4.1 DISPLAY TEXT
 633          If help information is requested by the user, this command may be used to display help information on the screen. The
 634          help information should be sent as high priority text and with the option that it should be cleared after a short delay.*/
 635
 636 /*      if (ctx->help_requested == TRUE) {
 637                 ad->bIsPriorityHigh = TRUE;
 638                 ad->duration = 7000;
 639                 ctx->help_requested = FALSE;
 640         }*/
 641
 642         //enqueue data and generate cmd_id
 643         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
 644         q_data.cmd_type = SAT_PROATV_CMD_DISPLAY_TEXT;
 645         memcpy((void*)&(q_data.cmd_data.displayTextInd), display_text_tlv, sizeof(struct tel_sat_display_text_tlv));
 646         sat_manager_enqueue_cmd(ctx, &q_data);
 647         command_id = q_data.cmd_id;
 648
 649         icon_id = g_variant_new("()");
 650
 651         display_text = g_variant_new("(isiibbbv)", command_id, text, text_len, duration,
 652                         high_priority, user_rsp_required, immediately_rsp, icon_id);
 653
 654         return display_text;
 655 }
 656
 657 GVariant* sat_manager_select_item_noti(struct custom_data *ctx, const char *plugin_name, struct tel_sat_select_item_tlv* select_item_tlv)
 658 {
 659         TcorePlugin *plg = NULL;
 660         GVariant *select_item = NULL;
 661         struct sat_manager_queue_data q_data;
 662
 663         int index = 0;
 664         gint command_id = 0, default_item_id = 0, menu_cnt = 0, text_len =0;
 665         gboolean help_info = FALSE;
 666         gchar text[SAT_TEXT_STRING_LEN_MAX];
 667         GVariantBuilder *v_builder = NULL;
 668         GVariant *menu_items = NULL;
 669         GVariant *icon_id = NULL;
 670         GVariant *icon_list = NULL;
 671
 672         dbg("interpreting select item notification");
 673         memset(&text, 0 , SAT_TEXT_STRING_LEN_MAX);
 674
 675         plg = tcore_server_find_plugin(ctx->server, plugin_name);
 676         if (!plg){
 677                 dbg("there is no valid plugin at this point");
 678                 return NULL;
 679         }
 680
 681         if ((select_item_tlv->icon_id.is_exist)
 682                         && (select_item_tlv->icon_id.icon_qualifer == ICON_QUALI_NOT_SELF_EXPLANATORY)
 683                         && ( !select_item_tlv->alpha_id.is_exist || select_item_tlv->alpha_id.alpha_data_len == 0) ) {
 684
 685                 struct treq_sat_terminal_rsp_data *tr = NULL;
 686                 dbg("[SAT]  exceptional case to fix gcf case 2.4 command not understood");
 687
 688                 tr = (struct treq_sat_terminal_rsp_data *) calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
 689
 690                 tr->cmd_number = select_item_tlv->command_detail.cmd_num;
 691                 tr->cmd_type = select_item_tlv->command_detail.cmd_type;
 692
 693                 memcpy((void*) &tr->terminal_rsp_data.select_item.command_detail, &select_item_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
 694                 tr->terminal_rsp_data.select_item.device_id.src = select_item_tlv->device_id.dest;
 695                 tr->terminal_rsp_data.select_item.device_id.dest = select_item_tlv->device_id.src;
 696                 tr->terminal_rsp_data.select_item.result_type = RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME;
 697
 698                 sat_manager_send_terminal_response(ctx->comm, plg, tr);
 699                 g_free(tr);
 700
 701                 return NULL;
 702         }
 703
 704         // help info
 705         help_info = select_item_tlv->command_detail.cmd_qualifier.select_item.help_info;
 706
 707         if(!select_item_tlv->alpha_id.is_exist){
 708                 dbg("set the item dcs value to ALPHABET_FORMAT_8BIT_DATA");
 709                 select_item_tlv->alpha_id.dcs.a_format = ALPHABET_FORMAT_8BIT_DATA;
 710         }
 711
 712         // select item text
 713         if(select_item_tlv->alpha_id.is_exist && select_item_tlv->alpha_id.alpha_data_len > 0)
 714                 tcore_util_convert_string_to_utf8((unsigned char*)&text,(unsigned short *)&text_len,
 715                                 select_item_tlv->alpha_id.dcs.a_format,
 716                                 (unsigned char*)&select_item_tlv->alpha_id.alpha_data,
 717                                 (unsigned short)select_item_tlv->alpha_id.alpha_data_len);
 718         dbg("select item text(%s)",text);
 719
 720         //default item id
 721         default_item_id = select_item_tlv->item_identifier.item_identifier;
 722         dbg( "default item id(%d)", default_item_id);
 723
 724         //item count
 725         menu_cnt = select_item_tlv->menu_item_cnt;
 726         dbg( "menu item count(%d)", menu_cnt);
 727
 728         //items
 729         v_builder = g_variant_builder_new(G_VARIANT_TYPE ("a(iis)"));
 730         for(index= 0; index< menu_cnt; index++){
 731                 gint item_len;
 732                 gchar item_str[SAT_ITEM_TEXT_LEN_MAX + 1];
 733
 734                 memset(&item_str, 0 , SAT_ITEM_TEXT_LEN_MAX + 1);
 735
 736                 tcore_util_convert_string_to_utf8((unsigned char*) &item_str, (unsigned short *) &item_len,
 737                                 select_item_tlv->alpha_id.dcs.a_format,
 738                                 (unsigned char*) &select_item_tlv->menu_item[index].text,
 739                                 (unsigned short) select_item_tlv->menu_item[index].text_len);
 740
 741                 if (select_item_tlv->item_next_act_ind_list.cnt != 0) {
 742                         if( select_item_tlv->item_next_act_ind_list.indicator_list[index] == SAT_PROATV_CMD_SEND_SMS) {
 743                                 g_strlcat(item_str," [Send SMS]", 11);
 744                         }
 745                         else if (select_item_tlv->item_next_act_ind_list.indicator_list[index]== SAT_PROATV_CMD_SETUP_CALL) {
 746                                 g_strlcat(item_str," [Set Up Call]", 14);
 747                         }
 748                         else if (select_item_tlv->item_next_act_ind_list.indicator_list[index]== SAT_PROATV_CMD_LAUNCH_BROWSER){
 749                                 g_strlcat(item_str," [Launch Browser]", 17);
 750                         }
 751                         else if (select_item_tlv->item_next_act_ind_list.indicator_list[index]== SAT_PROATV_CMD_PROVIDE_LOCAL_INFO)     {
 752                                 g_strlcat(item_str," [Provide Terminal Information]", 31);
 753                         }
 754                 }
 755
 756                 item_len = strlen(item_str);
 757                 dbg( "index(%d) item_id(%d) item_len(%d) item_string(%s)", index, select_item_tlv->menu_item[index].item_id, item_len, item_str);
 758                 g_variant_builder_add(v_builder, "(iis)", (gint32)(select_item_tlv->menu_item[index].item_id), item_len, item_str);
 759         }
 760         menu_items = g_variant_builder_end(v_builder);
 761
 762         // generate command id
 763         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
 764         q_data.cmd_type = SAT_PROATV_CMD_SELECT_ITEM;
 765         memcpy((void*)&(q_data.cmd_data.selectItemInd), select_item_tlv, sizeof(struct tel_sat_select_item_tlv));
 766         sat_manager_enqueue_cmd(ctx, &q_data);
 767         command_id = q_data.cmd_id;
 768
 769         icon_id = g_variant_new_variant(menu_items);
 770         icon_list = g_variant_new_variant(menu_items);
 771
 772         select_item = g_variant_new("(ibsiiivvv)", command_id, help_info, text, text_len,
 773                         default_item_id, menu_cnt, menu_items, icon_id, icon_list);
 774
 775         return select_item;
 776 }
 777
 778 GVariant* sat_manager_get_inkey_noti(struct custom_data *ctx, const char *plugin_name, struct tel_sat_get_inkey_tlv* get_inkey_tlv)
 779 {
 780         TcorePlugin *plg = NULL;
 781         GVariant *get_inkey = NULL;
 782         struct sat_manager_queue_data q_data;
 783
 784         gint command_id = 0, key_type = 0, input_character_mode = 0;
 785         gint text_len = 0, duration = 0, tmp_duration = 0;
 786         gboolean b_numeric = FALSE, b_help_info = FALSE;
 787         gchar text[SAT_TEXT_STRING_LEN_MAX];
 788         GVariant *icon_id = NULL;
 789
 790         dbg("interpreting get inkey notification");
 791         memset(&text, 0 , SAT_TEXT_STRING_LEN_MAX);
 792
 793         plg = tcore_server_find_plugin(ctx->server, plugin_name);
 794         if (!plg){
 795                 dbg("there is no valid plugin at this point");
 796                 return NULL;
 797         }
 798
 799         if (get_inkey_tlv->icon_id.is_exist && !get_inkey_tlv->text.string_length
 800                         && (get_inkey_tlv->icon_id.icon_qualifer == ICON_QUALI_NOT_SELF_EXPLANATORY)){
 801
 802                 struct treq_sat_terminal_rsp_data *tr = NULL;
 803                 dbg("[SAT]  exceptional case to fix gcf case 2.4 command not understood");
 804
 805                 tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
 806                 tr->cmd_number = get_inkey_tlv->command_detail.cmd_num;
 807                 tr->cmd_type = get_inkey_tlv->command_detail.cmd_type;
 808
 809                 memcpy((void*)&tr->terminal_rsp_data.get_inkey.command_detail, &get_inkey_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
 810                 tr->terminal_rsp_data.get_inkey.device_id.src = get_inkey_tlv->device_id.dest;
 811                 tr->terminal_rsp_data.get_inkey.device_id.dest = get_inkey_tlv->device_id.src;
 812                 tr->terminal_rsp_data.get_inkey.result_type = RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME;
 813
 814                 sat_manager_send_terminal_response(ctx->comm, plg, tr);
 815                 g_free(tr);
 816
 817                 return NULL;
 818         }
 819
 820         //key type
 821         key_type = get_inkey_tlv->command_detail.cmd_qualifier.get_inkey.inkey_type;
 822
 823         //time duration
 824         duration = SAT_TIME_OUT;
 825         tmp_duration = _get_time_in_ms(&get_inkey_tlv->duration);
 826         if (tmp_duration > 0)
 827                 duration = tmp_duration;
 828
 829         //input mode
 830         input_character_mode = get_inkey_tlv->command_detail.cmd_qualifier.get_inkey.alphabet_type;
 831
 832         //numeric
 833         b_numeric = !get_inkey_tlv->command_detail.cmd_qualifier.get_inkey.alphabet_set;
 834
 835         //help info
 836         b_help_info = get_inkey_tlv->command_detail.cmd_qualifier.get_inkey.help_info;
 837
 838         //text & text len
 839         tcore_util_convert_string_to_utf8((unsigned char*)&text,(unsigned short *)&text_len,
 840                                                                 get_inkey_tlv->text.dcs.a_format ,
 841                                                                 (unsigned char*)&get_inkey_tlv->text.string,
 842                                                                 (unsigned short)get_inkey_tlv->text.string_length);
 843
 844         dbg("get inkey text(%s)",text);
 845
 846         if (get_inkey_tlv->command_detail.cmd_qualifier.get_inkey.immediate_rsp_required) {
 847                 dbg("get_inkey immediate_rsp_require is TRUE");
 848                 //Send TR if UI display success
 849         }
 850
 851         //enqueue data and generate cmd_id
 852         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
 853         q_data.cmd_type = SAT_PROATV_CMD_GET_INKEY;
 854         memcpy((void*)&(q_data.cmd_data.getInkeyInd), get_inkey_tlv, sizeof(struct tel_sat_get_inkey_tlv));
 855         sat_manager_enqueue_cmd(ctx, &q_data);
 856         command_id = q_data.cmd_id;
 857
 858         icon_id = g_variant_new("()");
 859
 860         get_inkey = g_variant_new("(iiibbsiiv)", command_id, key_type, input_character_mode, b_numeric,
 861                         b_help_info, text, text_len, duration, icon_id);
 862
 863         return get_inkey;
 864 }
 865
 866 GVariant* sat_manager_get_input_noti(struct custom_data *ctx, const char *plugin_name, struct tel_sat_get_input_tlv* get_input_tlv)
 867 {
 868         TcorePlugin *plg = NULL;
 869         GVariant *get_input = NULL;
 870         struct sat_manager_queue_data q_data;
 871
 872         gint command_id = 0, input_character_mode = 0;
 873         gint text_len = 0, def_text_len = 0, rsp_len_min = 0, rsp_len_max = 0;
 874         gboolean b_numeric = FALSE, b_help_info = FALSE, b_echo_input = FALSE;
 875         gchar text[SAT_TEXT_STRING_LEN_MAX], def_text[SAT_TEXT_STRING_LEN_MAX];
 876         GVariant *icon_id = NULL;
 877
 878         dbg("interpreting get input notification");
 879         memset(&text, 0 , SAT_TEXT_STRING_LEN_MAX);
 880
 881         plg = tcore_server_find_plugin(ctx->server, plugin_name);
 882         if (!plg){
 883                 dbg("there is no valid plugin at this point");
 884                 return NULL;
 885         }
 886
 887         if(get_input_tlv->icon_id.is_exist && get_input_tlv->icon_id.icon_qualifer == ICON_QUALI_NOT_SELF_EXPLANATORY ){
 888
 889                 struct treq_sat_terminal_rsp_data *tr = NULL;
 890                 dbg("[SAT]  exceptional case to fix gcf case 2.4 command not understood");
 891
 892                 tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
 893                 tr->cmd_number = get_input_tlv->command_detail.cmd_num;
 894                 tr->cmd_type = get_input_tlv->command_detail.cmd_type;
 895
 896                 memcpy((void*)&tr->terminal_rsp_data.get_input.command_detail, &get_input_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
 897                 tr->terminal_rsp_data.get_input.device_id.src = get_input_tlv->device_id.dest;
 898                 tr->terminal_rsp_data.get_input.device_id.dest = get_input_tlv->device_id.src;
 899                 tr->terminal_rsp_data.get_input.result_type = RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME;
 900
 901                 sat_manager_send_terminal_response(ctx->comm, plg, tr);
 902
 903                 g_free(tr);
 904                 return NULL;
 905         }
 906
 907         dbg( "[SAT]  is SMS7 packing required [%d]",get_input_tlv->command_detail.cmd_qualifier.get_input.user_input_unpacked_format);
 908
 909         //input mode
 910         input_character_mode =  get_input_tlv->command_detail.cmd_qualifier.get_input.alphabet_type;
 911
 912         //numeric
 913         b_numeric = !get_input_tlv->command_detail.cmd_qualifier.get_input.alphabet_set;
 914
 915         //help info
 916         b_help_info = get_input_tlv->command_detail.cmd_qualifier.get_input.help_info;
 917
 918         //echo input
 919         b_echo_input = get_input_tlv->command_detail.cmd_qualifier.get_input.me_echo_user_input;
 920         dbg("numeric (%d), help info(%d), echo input(%d)", b_numeric, b_help_info, b_echo_input);
 921
 922         //text & text len
 923         if(get_input_tlv->text.string_length){
 924                 tcore_util_convert_string_to_utf8((unsigned char*)&text,(unsigned short *)&text_len,
 925                                 get_input_tlv->text.dcs.a_format ,
 926                                 (unsigned char*)&get_input_tlv->text.string,
 927                                 (unsigned short)get_input_tlv->text.string_length);
 928                 dbg("get input text(%s)",text);
 929         }
 930         else{
 931                 memcpy(text,"", 1);
 932                 text_len = 0;
 933         }
 934
 935         //response length min & max
 936         rsp_len_min = get_input_tlv->rsp_len.min;
 937         rsp_len_max = get_input_tlv->rsp_len.max;
 938
 939         //default text & default text len
 940         if(get_input_tlv->default_text.string_length){
 941                 tcore_util_convert_string_to_utf8((unsigned char*)&def_text,(unsigned short *)&def_text_len,
 942                                 get_input_tlv->text.dcs.a_format ,
 943                                 (unsigned char*)&get_input_tlv->default_text.string,
 944                                 (unsigned short)get_input_tlv->default_text.string_length);
 945                 dbg("get input default text(%s)",text);
 946         }
 947
 948         //enqueue data and generate cmd_id
 949         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
 950         q_data.cmd_type = SAT_PROATV_CMD_GET_INPUT;
 951         memcpy((void*)&(q_data.cmd_data.getInputInd), get_input_tlv, sizeof(struct tel_sat_get_input_tlv));
 952         sat_manager_enqueue_cmd(ctx, &q_data);
 953         command_id = q_data.cmd_id;
 954
 955         icon_id = g_variant_new("()");
 956
 957         get_input = g_variant_new("(iibbbsiiisiv)", command_id, input_character_mode, b_numeric, b_help_info,
 958                         b_echo_input, text, text_len, rsp_len_max, rsp_len_min, def_text, def_text_len, icon_id);
 959
 960         return get_input;
 961 }
 962
 963 GVariant* sat_manager_play_tone_noti(struct custom_data *ctx, const char *plugin_name, struct tel_sat_play_tone_tlv* play_tone_tlv)
 964 {
 965         TcorePlugin *plg = NULL;
 966         GVariant *play_tone = NULL;
 967         struct sat_manager_queue_data q_data;
 968
 969         gint command_id = 0, tone_type = 0, duration = 0, tmp_duration = 0;
 970         gint text_len = 0;
 971         gchar text[SAT_TEXT_STRING_LEN_MAX];
 972         GVariant *icon_id = NULL;
 973
 974         dbg("interpreting play tone notification");
 975         memset(&text, 0 , SAT_TEXT_STRING_LEN_MAX);
 976
 977         plg = tcore_server_find_plugin(ctx->server, plugin_name);
 978         if (!plg){
 979                 dbg("there is no valid plugin at this point");
 980                 return NULL;
 981         }
 982
 983         if( (play_tone_tlv->icon_id.is_exist) && ( play_tone_tlv->icon_id.icon_qualifer == ICON_QUALI_NOT_SELF_EXPLANATORY)
 984                         && (!play_tone_tlv->alpha_id.is_exist || !play_tone_tlv->alpha_id.alpha_data_len))
 985         {
 986                 struct treq_sat_terminal_rsp_data *tr = NULL;
 987                 dbg("[SAT]  exceptional case to fix gcf case 2.4 command not understood");
 988
 989                 tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
 990                 tr->cmd_number = play_tone_tlv->command_detail.cmd_num;
 991                 tr->cmd_type = play_tone_tlv->command_detail.cmd_type;
 992
 993                 memcpy((void*)&tr->terminal_rsp_data.play_tone.command_detail, &play_tone_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
 994                 tr->terminal_rsp_data.play_tone.device_id.src = DEVICE_ID_ME;
 995                 tr->terminal_rsp_data.play_tone.device_id.dest = play_tone_tlv->device_id.src;
 996                 tr->terminal_rsp_data.play_tone.result_type = RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME;
 997
 998                 sat_manager_send_terminal_response(ctx->comm, plg, tr);
 999                 g_free(tr);
1000
1001                 return NULL;
1002         }
1003
1004         //text and text len
1005         if( play_tone_tlv->alpha_id.is_exist && play_tone_tlv->alpha_id.alpha_data_len){
1006                 tcore_util_convert_string_to_utf8((unsigned char*)&text,(unsigned short *)&text_len,
1007                                 play_tone_tlv->alpha_id.dcs.a_format,
1008                                 (unsigned char*)&play_tone_tlv->alpha_id.alpha_data,
1009                                 (unsigned short)play_tone_tlv->alpha_id.alpha_data_len);
1010                 dbg("play tone ui display text (%s)",text);
1011         }
1012
1013         //tone type
1014         tone_type = play_tone_tlv->tone.tone_type;
1015
1016         //time duration
1017         duration = SAT_TIME_OUT;
1018         tmp_duration = _get_time_in_ms(&play_tone_tlv->duration);
1019         if (tmp_duration > 0)
1020                 duration = tmp_duration;
1021
1022         //enqueue data and generate cmd_id
1023         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
1024         q_data.cmd_type = SAT_PROATV_CMD_PLAY_TONE;
1025         memcpy((void*)&(q_data.cmd_data.play_tone), play_tone_tlv, sizeof(struct tel_sat_play_tone_tlv));
1026         sat_manager_enqueue_cmd(ctx, &q_data);
1027         command_id = q_data.cmd_id;
1028
1029         icon_id = g_variant_new("()");
1030
1031         play_tone = g_variant_new("(isivii)", command_id, text, text_len, icon_id, tone_type, duration);
1032
1033         return play_tone;
1034 }
1035
1036 GVariant* sat_manager_send_sms_noti(struct custom_data *ctx, const char *plugin_name, struct tel_sat_send_sms_tlv* send_sms_tlv)
1037 {
1038         TcorePlugin *plg = NULL;
1039         GVariant *send_sms = NULL;
1040         struct sat_manager_queue_data q_data;
1041
1042         int index = 0;
1043         gint command_id = 0, ton = 0, npi = 0, tpdu_type = 0;
1044         gboolean b_packing_required = FALSE;
1045         gint text_len = 0, number_len = 0, tpdu_data_len= 0;
1046         gchar text[SAT_TEXT_STRING_LEN_MAX], dialling_number[SAT_DIALING_NUMBER_LEN_MAX];
1047         GVariantBuilder *builder = NULL;
1048         GVariant *tpdu_data = NULL;
1049         GVariant *icon_id = NULL;
1050
1051         dbg("interpreting send sms notification");
1052         memset(&text, 0 , SAT_TEXT_STRING_LEN_MAX);
1053         memset(&dialling_number, 0 , SAT_DIALING_NUMBER_LEN_MAX);
1054
1055         plg = tcore_server_find_plugin(ctx->server, plugin_name);
1056         if (!plg){
1057                 dbg("there is no valid plugin at this point");
1058                 return NULL;
1059         }
1060
1061         if( (send_sms_tlv->icon_id.is_exist) && ( send_sms_tlv->icon_id.icon_qualifer == ICON_QUALI_NOT_SELF_EXPLANATORY)
1062                         && (!send_sms_tlv->alpha_id.is_exist || !send_sms_tlv->alpha_id.alpha_data_len))
1063         {
1064                 struct treq_sat_terminal_rsp_data *tr = NULL;
1065                 dbg("[SAT]  exceptional case to fix gcf case 2.4 command not understood");
1066
1067                 tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
1068                 tr->cmd_number = send_sms_tlv->command_detail.cmd_num;
1069                 tr->cmd_type = send_sms_tlv->command_detail.cmd_type;
1070
1071                 memcpy((void*)&tr->terminal_rsp_data.send_sms.command_detail, &send_sms_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
1072                 tr->terminal_rsp_data.send_sms.device_id.src = DEVICE_ID_ME;
1073                 tr->terminal_rsp_data.send_sms.device_id.dest = send_sms_tlv->device_id.src;
1074                 tr->terminal_rsp_data.send_sms.result_type = RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME;
1075
1076                 sat_manager_send_terminal_response(ctx->comm, plg, tr);
1077                 g_free(tr);
1078
1079                 return NULL;
1080         }
1081
1082         //text and text len
1083         if( send_sms_tlv->alpha_id.is_exist && send_sms_tlv->alpha_id.alpha_data_len){
1084                 tcore_util_convert_string_to_utf8((unsigned char*)&text,(unsigned short *)&text_len,
1085                                 send_sms_tlv->alpha_id.dcs.a_format,
1086                                 (unsigned char*)&send_sms_tlv->alpha_id.alpha_data,
1087                                 (unsigned short)send_sms_tlv->alpha_id.alpha_data_len);
1088                 dbg("send sms ui display text (%s)",text);
1089         }
1090         else{
1091                 memcpy(text,"",1);
1092                 text_len = 0;
1093         }
1094
1095         //packing required
1096         b_packing_required = send_sms_tlv->command_detail.cmd_qualifier.send_sms.packing_by_me_required;
1097
1098         //address : ton, npi, dialling number, number len
1099         ton = send_sms_tlv->address.ton;
1100         npi = send_sms_tlv->address.npi;
1101         number_len = send_sms_tlv->address.dialing_number_len;
1102         memcpy(dialling_number, send_sms_tlv->address.dialing_number, SAT_DIALING_NUMBER_LEN_MAX);
1103
1104         //tpdu data : type, data, data len
1105         tpdu_type = send_sms_tlv->sms_tpdu.tpdu_type;
1106         tpdu_data_len = send_sms_tlv->sms_tpdu.data_len;
1107         builder = g_variant_builder_new(G_VARIANT_TYPE ("ay"));
1108         for (index = 0; index < tpdu_data_len; index++) {
1109                 g_variant_builder_add(builder, "y", send_sms_tlv->sms_tpdu.data[index]);
1110         }
1111         tpdu_data = g_variant_builder_end(builder);
1112
1113         //enqueue data and generate cmd_id
1114         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
1115         q_data.cmd_type = SAT_PROATV_CMD_SEND_SMS;
1116         memcpy((void*)&(q_data.cmd_data.sendSMSInd), send_sms_tlv, sizeof(struct tel_sat_send_sms_tlv));
1117         sat_manager_enqueue_cmd(ctx, &q_data);
1118         command_id = q_data.cmd_id;
1119
1120         icon_id = g_variant_new("()");
1121
1122         send_sms = g_variant_new("(isivbiisiivi)", command_id, text, text_len, icon_id, b_packing_required,
1123                         ton, npi, dialling_number, number_len, tpdu_type, tpdu_data, tpdu_data_len);
1124
1125         return send_sms;
1126 }
1127
1128 GVariant* sat_manager_send_ss_noti(struct custom_data *ctx, const char *plugin_name, struct tel_sat_send_ss_tlv* send_ss_tlv)
1129 {
1130         TcorePlugin *plg = NULL;
1131         GVariant *send_ss = NULL;
1132         struct sat_manager_queue_data q_data;
1133
1134         gint command_id = 0, ton = 0, npi = 0;
1135         gint text_len = 0, ss_str_len = 0;
1136         gchar text[SAT_TEXT_STRING_LEN_MAX], ss_string[SAT_SS_STRING_LEN_MAX];
1137         GVariant *icon_id = NULL;
1138
1139         dbg("interpreting send ss notification");
1140         memset(&text, 0 , SAT_TEXT_STRING_LEN_MAX);
1141         memset(&ss_string, 0 , SAT_SS_STRING_LEN_MAX);
1142
1143         plg = tcore_server_find_plugin(ctx->server, plugin_name);
1144         if (!plg){
1145                 dbg("there is no valid plugin at this point");
1146                 return NULL;
1147         }
1148
1149         if( (send_ss_tlv->icon_id.is_exist) && ( send_ss_tlv->icon_id.icon_qualifer == ICON_QUALI_NOT_SELF_EXPLANATORY)
1150                         && (!send_ss_tlv->alpha_id.is_exist || !send_ss_tlv->alpha_id.alpha_data_len))
1151         {
1152                 struct treq_sat_terminal_rsp_data *tr = NULL;
1153                 dbg("[SAT]  exceptional case to fix gcf case 2.4 command not understood");
1154
1155                 tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
1156                 tr->cmd_number = send_ss_tlv->command_detail.cmd_num;
1157                 tr->cmd_type = send_ss_tlv->command_detail.cmd_type;
1158
1159                 memcpy((void*)&tr->terminal_rsp_data.send_ss.command_detail, &send_ss_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
1160                 tr->terminal_rsp_data.send_ss.device_id.src = send_ss_tlv->device_id.dest;
1161                 tr->terminal_rsp_data.send_ss.device_id.dest = send_ss_tlv->device_id.src;
1162                 tr->terminal_rsp_data.send_ss.result_type = RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME;
1163
1164                 sat_manager_send_terminal_response(ctx->comm, plg, tr);
1165                 g_free(tr);
1166
1167                 return NULL;
1168         }
1169
1170         //text and text len
1171         if( send_ss_tlv->alpha_id.is_exist && send_ss_tlv->alpha_id.alpha_data_len){
1172                 tcore_util_convert_string_to_utf8((unsigned char*)&text,(unsigned short *)&text_len,
1173                                 send_ss_tlv->alpha_id.dcs.a_format,
1174                                 (unsigned char*)&send_ss_tlv->alpha_id.alpha_data,
1175                                 (unsigned short)send_ss_tlv->alpha_id.alpha_data_len);
1176                 dbg("send ss ui display text (%s)",text);
1177         }
1178
1179         //ss string: ton, npi, ss string len, ss string
1180         ton = send_ss_tlv->ss_string.ton;
1181         npi = send_ss_tlv->ss_string.npi;
1182         ss_str_len = send_ss_tlv->ss_string.string_len;
1183         memcpy(ss_string, send_ss_tlv->ss_string.ss_string, SAT_SS_STRING_LEN_MAX);
1184
1185         //enqueue data and generate cmd_id
1186         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
1187         q_data.cmd_type = SAT_PROATV_CMD_SEND_SS;
1188         memcpy((void*)&(q_data.cmd_data.send_ss), send_ss_tlv, sizeof(struct tel_sat_send_ss_tlv));
1189         sat_manager_enqueue_cmd(ctx, &q_data);
1190         command_id = q_data.cmd_id;
1191
1192         icon_id = g_variant_new("()");
1193
1194         send_ss = g_variant_new("(isiviiis)", command_id, text, text_len, icon_id,
1195                         ton, npi, ss_str_len, ss_string);
1196
1197         return send_ss;
1198 }
1199
1200 GVariant* sat_manager_send_ussd_noti(struct custom_data *ctx, const char *plugin_name, struct tel_sat_send_ussd_tlv* send_ussd_tlv)
1201 {
1202         TcorePlugin *plg = NULL;
1203         GVariant *send_ussd = NULL;
1204         struct sat_manager_queue_data q_data;
1205
1206         gint command_id = 0;
1207         gint text_len = 0, ussd_str_len = 0;
1208         gchar text[SAT_TEXT_STRING_LEN_MAX], ussd_string[SAT_USSD_STRING_LEN_MAX];
1209         GVariant *icon_id = NULL;
1210
1211         dbg("interpreting send ussd notification");
1212         memset(&text, 0 , SAT_TEXT_STRING_LEN_MAX);
1213         memset(&ussd_string, 0 , SAT_USSD_STRING_LEN_MAX);
1214
1215         plg = tcore_server_find_plugin(ctx->server, plugin_name);
1216         if (!plg){
1217                 dbg("there is no valid plugin at this point");
1218                 return NULL;
1219         }
1220
1221         if( (send_ussd_tlv->icon_id.is_exist) && ( send_ussd_tlv->icon_id.icon_qualifer == ICON_QUALI_NOT_SELF_EXPLANATORY)
1222                         && (!send_ussd_tlv->alpha_id.is_exist || !send_ussd_tlv->alpha_id.alpha_data_len))
1223         {
1224                 struct treq_sat_terminal_rsp_data *tr = NULL;
1225                 dbg("[SAT]  exceptional case to fix gcf case 2.4 command not understood");
1226
1227                 tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
1228                 tr->cmd_number = send_ussd_tlv->command_detail.cmd_num;
1229                 tr->cmd_type = send_ussd_tlv->command_detail.cmd_type;
1230
1231                 memcpy((void*)&tr->terminal_rsp_data.send_ussd.command_detail, &send_ussd_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
1232                 tr->terminal_rsp_data.send_ussd.device_id.src = send_ussd_tlv->device_id.dest;
1233                 tr->terminal_rsp_data.send_ussd.device_id.dest = send_ussd_tlv->device_id.src;
1234                 tr->terminal_rsp_data.send_ussd.result_type = RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME;
1235
1236                 sat_manager_send_terminal_response(ctx->comm, plg, tr);
1237                 g_free(tr);
1238
1239                 return NULL;
1240         }
1241
1242         //text and text len
1243         if( send_ussd_tlv->alpha_id.is_exist && send_ussd_tlv->alpha_id.alpha_data_len){
1244                 tcore_util_convert_string_to_utf8((unsigned char*)&text,(unsigned short *)&text_len,
1245                                 send_ussd_tlv->alpha_id.dcs.a_format,
1246                                 (unsigned char*)&send_ussd_tlv->alpha_id.alpha_data,
1247                                 (unsigned short)send_ussd_tlv->alpha_id.alpha_data_len);
1248                 dbg("send ussd ui display text (%s)",text);
1249         }
1250
1251         //ussd string
1252         tcore_util_convert_string_to_utf8((unsigned char*)&ussd_string,(unsigned short *)&ussd_str_len,
1253                                 send_ussd_tlv->ussd_string.dsc.a_format,
1254                                 (unsigned char*)&send_ussd_tlv->ussd_string.ussd_string,
1255                                 (unsigned short)send_ussd_tlv->ussd_string.string_len);
1256
1257         //enqueue data and generate cmd_id
1258         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
1259         q_data.cmd_type = SAT_PROATV_CMD_SEND_USSD;
1260         memcpy((void*)&(q_data.cmd_data.send_ussd), send_ussd_tlv, sizeof(struct tel_sat_send_ussd_tlv));
1261         sat_manager_enqueue_cmd(ctx, &q_data);
1262         command_id = q_data.cmd_id;
1263
1264         icon_id = g_variant_new("()");
1265
1266         send_ussd = g_variant_new("(isivis)", command_id, text, text_len, icon_id, ussd_str_len, ussd_string);
1267
1268         return send_ussd;
1269 }
1270
1271 GVariant* sat_manager_setup_call_noti(struct custom_data *ctx, const char *plugin_name, struct tel_sat_setup_call_tlv* setup_call_tlv)
1272 {
1273         TcorePlugin *plg = NULL;
1274         GVariant *setup_call = NULL;
1275         struct sat_manager_queue_data q_data;
1276
1277         gint command_id = 0, call_type = 0, confirm_text_len = 0, text_len = 0, duration = 0;
1278         gchar confirm_text[SAT_TEXT_STRING_LEN_MAX], text[SAT_TEXT_STRING_LEN_MAX], call_number[SAT_DIALING_NUMBER_LEN_MAX];
1279         GVariant *icon_id = NULL;
1280
1281         dbg("interpreting setup call notification");
1282         memset(&confirm_text, 0 , SAT_TEXT_STRING_LEN_MAX);
1283         memset(&text, 0 , SAT_TEXT_STRING_LEN_MAX);
1284         memset(&call_number, 0 , SAT_DIALING_NUMBER_LEN_MAX);
1285
1286         plg = tcore_server_find_plugin(ctx->server, plugin_name);
1287         if (!plg){
1288                 dbg("there is no valid plugin at this point");
1289                 return NULL;
1290         }
1291
1292         if(setup_call_tlv->duration.time_interval > 0)
1293         {
1294                 struct treq_sat_terminal_rsp_data *tr = NULL;
1295                 dbg("[SAT] redial is not supported.\n");
1296
1297                 tr = g_new0(struct treq_sat_terminal_rsp_data, 1);
1298                 tr->cmd_number = setup_call_tlv->command_detail.cmd_num;
1299                 tr->cmd_type = setup_call_tlv->command_detail.cmd_type;
1300
1301                 memcpy((void*)&tr->terminal_rsp_data.setup_call.command_detail, &setup_call_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
1302                 tr->terminal_rsp_data.setup_call.device_id.src = DEVICE_ID_ME;
1303                 tr->terminal_rsp_data.setup_call.device_id.dest = setup_call_tlv->device_id.src;
1304                 tr->terminal_rsp_data.setup_call.result_type = RESULT_BEYOND_ME_CAPABILITIES;
1305
1306                 sat_manager_send_terminal_response(ctx->comm, plg, tr);
1307                 g_free(tr);
1308                 return NULL;
1309         }
1310
1311         //check for subaddress field
1312         if(setup_call_tlv->subaddress.subaddress_len > 0)
1313         {
1314                 struct treq_sat_terminal_rsp_data *tr = NULL;
1315                 dbg("[SAT] Sub address is not supported > 0)");
1316
1317                 tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
1318                 tr->cmd_number = setup_call_tlv->command_detail.cmd_num;
1319                 tr->cmd_type = setup_call_tlv->command_detail.cmd_type;
1320
1321                 memcpy((void*)&tr->terminal_rsp_data.setup_call.command_detail, &setup_call_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
1322                 tr->terminal_rsp_data.setup_call.device_id.src = DEVICE_ID_ME;
1323                 tr->terminal_rsp_data.setup_call.device_id.dest = setup_call_tlv->device_id.src;
1324                 tr->terminal_rsp_data.setup_call.result_type = RESULT_BEYOND_ME_CAPABILITIES;
1325
1326                 sat_manager_send_terminal_response(ctx->comm, plg, tr);
1327                 g_free(tr);
1328                 return NULL;
1329         }
1330
1331         //call type
1332         call_type = setup_call_tlv->command_detail.cmd_qualifier.setup_call.setup_call;
1333
1334         //call display data
1335         if(setup_call_tlv->call_setup_alpha_id.alpha_data_len != 0){
1336                 tcore_util_convert_string_to_utf8((unsigned char*)&text,(unsigned short *)&text_len,
1337                                 setup_call_tlv->call_setup_alpha_id.dcs.a_format,
1338                                 (unsigned char*)&setup_call_tlv->call_setup_alpha_id.alpha_data,
1339                                 (unsigned short)setup_call_tlv->call_setup_alpha_id.alpha_data_len);
1340         }
1341         else{
1342                 memcpy(text, setup_call_tlv->address.dialing_number, setup_call_tlv->address.dialing_number_len);
1343                 text_len = setup_call_tlv->address.dialing_number_len;
1344         }
1345         dbg("setup call display text (%s)",text);
1346
1347         if(setup_call_tlv->user_confirm_alpha_id.alpha_data_len != 0){
1348                 tcore_util_convert_string_to_utf8((unsigned char*)&confirm_text,(unsigned short *)&confirm_text_len,
1349                                 setup_call_tlv->user_confirm_alpha_id.dcs.a_format,
1350                                 (unsigned char*)&setup_call_tlv->user_confirm_alpha_id.alpha_data,
1351                                 (unsigned short)setup_call_tlv->user_confirm_alpha_id.alpha_data_len);
1352         }
1353
1354         //call number
1355         if(setup_call_tlv->address.ton == TON_INTERNATIONAL){
1356                 call_number[0] = '+';
1357                 memcpy(&call_number[1],setup_call_tlv->address.dialing_number, setup_call_tlv->address.dialing_number_len);
1358         }
1359         else{
1360                 memcpy(call_number,setup_call_tlv->address.dialing_number, setup_call_tlv->address.dialing_number_len);
1361         }
1362         dbg("setup call call number(%s)",setup_call_tlv->address.dialing_number);
1363
1364         //duration
1365         if(setup_call_tlv->duration.time_interval > 0)
1366                 duration = _get_time_in_ms(&setup_call_tlv->duration);
1367
1368         //enqueue data and generate cmd_id
1369         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
1370         q_data.cmd_type = SAT_PROATV_CMD_SETUP_CALL;
1371         memcpy((void*)&(q_data.cmd_data.setup_call), setup_call_tlv, sizeof(struct tel_sat_setup_call_tlv));
1372         sat_manager_enqueue_cmd(ctx, &q_data);
1373         command_id = q_data.cmd_id;
1374
1375         icon_id = g_variant_new("()");
1376
1377         setup_call = g_variant_new("(isisivisi)", command_id, confirm_text, confirm_text_len, text, text_len, icon_id, call_type, call_number, duration);
1378
1379         return setup_call;
1380 }
1381
1382 GVariant* sat_manager_setup_event_list_noti(struct custom_data *ctx, const char *plugin_name, struct tel_sat_setup_event_list_tlv *event_list_tlv)
1383 {
1384         TcorePlugin *plg = NULL;
1385         GVariant *event_list = NULL;
1386
1387         int index = 0;
1388         gboolean rv = FALSE;
1389         gint event_cnt = 0;
1390         GVariantBuilder *builder = NULL;
1391         GVariant *evt_list = NULL;
1392         struct treq_sat_terminal_rsp_data *tr = NULL;
1393
1394         dbg("interpreting event list notification");
1395
1396         plg = tcore_server_find_plugin(ctx->server, plugin_name);
1397         if (!plg){
1398                 dbg("there is no valid plugin at this point");
1399                 return NULL;
1400         }
1401
1402         //event cnt
1403         event_cnt = event_list_tlv->event_list.event_list_cnt;
1404         dbg("event cnt(%d)", event_cnt);
1405
1406         //get event
1407         builder = g_variant_builder_new(G_VARIANT_TYPE ("ai"));
1408         for (index = 0; index < event_cnt; index++) {
1409                 g_variant_builder_add(builder, "i", event_list_tlv->event_list.evt_list[index]);
1410         }
1411         evt_list = g_variant_builder_end(builder);
1412
1413         event_list = g_variant_new("(iv)", event_cnt, evt_list);
1414
1415         //send TR - does not need from application's response
1416         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
1417         tr->cmd_number = event_list_tlv->command_detail.cmd_num;
1418         tr->cmd_type = event_list_tlv->command_detail.cmd_type;
1419         memcpy((void*)&tr->terminal_rsp_data.setup_event_list.command_detail, &event_list_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
1420         tr->terminal_rsp_data.setup_event_list.device_id.src = event_list_tlv->device_id.dest;
1421         tr->terminal_rsp_data.setup_event_list.device_id.dest = event_list_tlv->device_id.src;
1422         tr->terminal_rsp_data.setup_event_list.result_type = RESULT_SUCCESS;
1423         tr->terminal_rsp_data.setup_event_list.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
1424
1425         rv = sat_manager_check_availiable_event_list(event_list_tlv);
1426         sat_manager_send_terminal_response(ctx->comm, plg, tr);
1427         g_free(tr);
1428
1429         return event_list;
1430 }
1431
1432 GVariant* sat_manager_setup_idle_mode_text_noti(struct custom_data *ctx, const char *plugin_name, struct tel_sat_setup_idle_mode_text_tlv *idle_mode_tlv)
1433 {
1434         TcorePlugin *plg = NULL;
1435         GVariant *idle_mode = NULL;
1436         struct sat_manager_queue_data q_data;
1437
1438         gint command_id = 0;
1439         gint text_len = 0;
1440         gchar text[SAT_TEXT_STRING_LEN_MAX];
1441         GVariant *icon_id = NULL;
1442
1443         dbg("interpreting setup idle mode text notification");
1444         memset(&text, 0 , SAT_TEXT_STRING_LEN_MAX);
1445
1446         plg = tcore_server_find_plugin(ctx->server, plugin_name);
1447         if (!plg){
1448                 dbg("there is no valid plugin at this point");
1449                 return NULL;
1450         }
1451
1452         if( ((idle_mode_tlv->icon_id.is_exist) && ( idle_mode_tlv->icon_id.icon_qualifer == ICON_QUALI_NOT_SELF_EXPLANATORY))
1453                         && idle_mode_tlv->text.string_length == 0 )
1454         {
1455                 struct treq_sat_terminal_rsp_data *tr = NULL;
1456                 dbg("[SAT]  exceptional case to fix gcf case 2.4 command not understood");
1457
1458                 tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
1459                 tr->cmd_number = idle_mode_tlv->command_detail.cmd_num;
1460                 tr->cmd_type = idle_mode_tlv->command_detail.cmd_type;
1461
1462                 memcpy((void*)&tr->terminal_rsp_data.setup_idle_mode_text.command_detail, &idle_mode_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
1463                 tr->terminal_rsp_data.setup_idle_mode_text.device_id.src = idle_mode_tlv->device_id.dest;
1464                 tr->terminal_rsp_data.setup_idle_mode_text.device_id.dest = idle_mode_tlv->device_id.src;
1465                 tr->terminal_rsp_data.setup_idle_mode_text.result_type = RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME;
1466
1467                 sat_manager_send_terminal_response(ctx->comm, plg, tr);
1468                 g_free(tr);
1469                 return NULL;
1470         }
1471
1472         tcore_util_convert_string_to_utf8((unsigned char*)&text,(unsigned short *)&text_len,
1473                         idle_mode_tlv->text.dcs.a_format,
1474                         (unsigned char*)&idle_mode_tlv->text.string,
1475                         (unsigned short)idle_mode_tlv->text.string_length);
1476
1477         dbg("setup idle mode text display text (%s)",text);
1478
1479         //enqueue data and generate cmd_id
1480         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
1481         q_data.cmd_type = SAT_PROATV_CMD_SETUP_IDLE_MODE_TEXT;
1482         memcpy((void*)&(q_data.cmd_data.idle_mode), idle_mode_tlv, sizeof(struct tel_sat_setup_idle_mode_text_tlv));
1483         sat_manager_enqueue_cmd(ctx, &q_data);
1484         command_id = q_data.cmd_id;
1485
1486         icon_id = g_variant_new("()");
1487
1488         idle_mode = g_variant_new("(isiv)", command_id, text, text_len, icon_id);
1489
1490         return idle_mode;
1491 }
1492
1493 GVariant* sat_manager_open_channel_noti(struct custom_data *ctx, const char *plugin_name, struct tel_sat_open_channel_tlv *open_channel_tlv)
1494 {
1495         TcorePlugin *plg = NULL;
1496         GVariant *open_channel = NULL;
1497         struct sat_manager_queue_data q_data;
1498
1499         gint command_id = 0, bearer_type = 0, protocol_type = 0, dest_addr_type = 0;
1500         gboolean immediate_link = FALSE, auto_reconnection = FALSE, bg_mode = FALSE;
1501         gint text_len = 0, buffer_size = 0, port_number = 0;
1502         gchar text[SAT_ALPHA_ID_LEN_MAX], dest_address[SAT_OTHER_ADDR_LEN_MAX];
1503         GVariant *icon_id = NULL;
1504         GVariant *bearer_param = NULL;
1505         GVariant *bearer_detail = NULL;
1506
1507         dbg("interpreting open channel notification");
1508         memset(&text, 0 , SAT_ALPHA_ID_LEN_MAX);
1509         memset(&dest_address, 0 , SAT_OTHER_ADDR_LEN_MAX);
1510
1511         plg = tcore_server_find_plugin(ctx->server, plugin_name);
1512         if (!plg){
1513                 dbg("there is no valid plugin at this point");
1514                 return NULL;
1515         }
1516
1517         //immediate link
1518         immediate_link = open_channel_tlv->command_detail.cmd_qualifier.open_channel.immediate_link;
1519
1520         //auto reconnection
1521         auto_reconnection = open_channel_tlv->command_detail.cmd_qualifier.open_channel.automatic_reconnection;
1522
1523         //back ground mode
1524         bg_mode = open_channel_tlv->command_detail.cmd_qualifier.open_channel.background_mode;
1525
1526         //open channel text
1527         if(open_channel_tlv->alpha_id.is_exist && open_channel_tlv->alpha_id.alpha_data_len > 0)
1528                 tcore_util_convert_string_to_utf8((unsigned char*)&text,(unsigned short *)&text_len,
1529                                 open_channel_tlv->alpha_id.dcs.a_format,
1530                                 (unsigned char*)&open_channel_tlv->alpha_id.alpha_data,
1531                                 (unsigned short)open_channel_tlv->alpha_id.alpha_data_len);
1532         dbg("open channel text(%s)",text);
1533
1534         //buffer size
1535         buffer_size = open_channel_tlv->buffer_size.size[0];
1536         buffer_size = buffer_size << 8;
1537         buffer_size += open_channel_tlv->buffer_size.size[1];
1538         //memcpy(&buffer_size, open_channel_tlv->buffer_size.size, sizeof(unsigned char)*2);
1539         dbg("buffer size(%d)", buffer_size);
1540
1541         //interface transport level
1542         protocol_type = open_channel_tlv->interface_transport_level.protocol_type;
1543         port_number = open_channel_tlv->interface_transport_level.port_number;
1544
1545         //data destination address
1546         dest_addr_type = open_channel_tlv->data_destination_address.address_type;
1547         memcpy(dest_address, open_channel_tlv->data_destination_address.address, open_channel_tlv->data_destination_address.address_len);
1548         dbg("destination IP address (%s)", dest_address);
1549
1550         //bearer type
1551         bearer_type = open_channel_tlv->bearer_desc.bearer_type;
1552
1553         //bearer param & bearer detail
1554         switch(bearer_type){
1555                 case BEARER_CSD:{
1556                         //bearer param
1557                         gint data_rate = 0, service_type = 0, conn_element_type = 0;
1558
1559                         //bearer detail
1560                         gint ton = 0, npi = 0, time_duration1 = 0, time_duration2 = 0, other_addr_type = 0;
1561                         gint login_len = 0, pwd_len = 0;
1562                         gchar dialling_number[SAT_DIALING_NUMBER_LEN_MAX], sub_addr[SAT_SUB_ADDR_LEN_MAX];
1563                         gchar other_address[SAT_OTHER_ADDR_LEN_MAX];
1564                         gchar login[SAT_TEXT_STRING_LEN_MAX], pwd[SAT_TEXT_STRING_LEN_MAX];
1565
1566                         memset(&dialling_number, 0 , SAT_DIALING_NUMBER_LEN_MAX);
1567                         memset(&sub_addr, 0 , SAT_SUB_ADDR_LEN_MAX);
1568                         memset(&other_address, 0 , SAT_OTHER_ADDR_LEN_MAX);
1569                         memset(&login, 0 , SAT_TEXT_STRING_LEN_MAX);
1570                         memset(&pwd, 0 , SAT_TEXT_STRING_LEN_MAX);
1571
1572                         //bearer parameter
1573                         data_rate = open_channel_tlv->bearer_desc.bearer_parameter.cs_bearer_param.data_rate;
1574                         service_type = open_channel_tlv->bearer_desc.bearer_parameter.cs_bearer_param.service_type;
1575                         conn_element_type = open_channel_tlv->bearer_desc.bearer_parameter.cs_bearer_param.connection_element_type;
1576
1577                         bearer_param = g_variant_new("(iii)", data_rate, service_type, conn_element_type);
1578
1579                         //bearer detail
1580                         ton = open_channel_tlv->bearer_detail.cs_bearer.address.ton;
1581                         npi = open_channel_tlv->bearer_detail.cs_bearer.address.npi;
1582                         memcpy(dialling_number, open_channel_tlv->bearer_detail.cs_bearer.address.dialing_number, open_channel_tlv->bearer_detail.cs_bearer.address.dialing_number_len);
1583
1584                         memcpy(sub_addr, open_channel_tlv->bearer_detail.cs_bearer.subaddress.subaddress, open_channel_tlv->bearer_detail.cs_bearer.subaddress.subaddress_len);
1585
1586                         time_duration1 = _get_time_in_ms(&open_channel_tlv->bearer_detail.cs_bearer.duration1);
1587                         time_duration2 = _get_time_in_ms(&open_channel_tlv->bearer_detail.cs_bearer.duration2);
1588
1589                         other_addr_type = open_channel_tlv->bearer_detail.cs_bearer.other_address.address_type;
1590                         memcpy(other_address, open_channel_tlv->bearer_detail.cs_bearer.other_address.address, open_channel_tlv->bearer_detail.cs_bearer.other_address.address_len);
1591
1592                         tcore_util_convert_string_to_utf8((unsigned char*) &login, (unsigned short *) &login_len,
1593                                         open_channel_tlv->bearer_detail.cs_bearer.text_user_login.dcs.a_format,
1594                                         (unsigned char*) &open_channel_tlv->bearer_detail.cs_bearer.text_user_login.string,
1595                                         (unsigned short) open_channel_tlv->bearer_detail.cs_bearer.text_user_login.string_length);
1596
1597                         tcore_util_convert_string_to_utf8((unsigned char*) &pwd, (unsigned short *) &pwd_len,
1598                                         open_channel_tlv->bearer_detail.cs_bearer.text_user_pwd.dcs.a_format,
1599                                         (unsigned char*) &open_channel_tlv->bearer_detail.cs_bearer.text_user_pwd.string,
1600                                         (unsigned short) open_channel_tlv->bearer_detail.cs_bearer.text_user_pwd.string_length);
1601
1602                         bearer_detail= g_variant_new("(iissiiisss)", ton, npi, dialling_number, sub_addr, time_duration1, time_duration2,
1603                                         other_addr_type, other_address, login, pwd);
1604                 } break;
1605                 case BEARER_GPRS:{
1606                         //bearer param
1607                         gint precedence_class = 0, delay_class = 0, reliability_class = 0;
1608                         gint peak_class = 0, mean_class = 0, pdp_type = 0;
1609
1610                         //bearer detail
1611                         gint other_addr_type = 0;
1612                         gint login_len = 0, pwd_len = 0;
1613                         gchar network_access_name[SAT_NET_ACC_NAM_LEN_MAX];
1614                         gchar other_address[SAT_OTHER_ADDR_LEN_MAX];
1615                         gchar login[SAT_TEXT_STRING_LEN_MAX], pwd[SAT_TEXT_STRING_LEN_MAX];
1616
1617                         memset(&network_access_name, 0 , SAT_NET_ACC_NAM_LEN_MAX);
1618                         memset(&other_address, 0 , SAT_OTHER_ADDR_LEN_MAX);
1619                         memset(&login, 0 , SAT_TEXT_STRING_LEN_MAX);
1620                         memset(&pwd, 0 , SAT_TEXT_STRING_LEN_MAX);
1621
1622                         //bearer parameter
1623                         precedence_class = open_channel_tlv->bearer_desc.bearer_parameter.ps_bearer_param.precedence_class;
1624                         delay_class = open_channel_tlv->bearer_desc.bearer_parameter.ps_bearer_param.delay_class;
1625                         reliability_class = open_channel_tlv->bearer_desc.bearer_parameter.ps_bearer_param.reliability_class;
1626                         peak_class = open_channel_tlv->bearer_desc.bearer_parameter.ps_bearer_param.peak_throughput_class;
1627                         mean_class = open_channel_tlv->bearer_desc.bearer_parameter.ps_bearer_param.mean_throughput_class;
1628                         pdp_type = open_channel_tlv->bearer_desc.bearer_parameter.ps_bearer_param.pdp_type;
1629
1630                         bearer_param = g_variant_new("(iiiiii)", precedence_class, delay_class, reliability_class, peak_class, mean_class, pdp_type);
1631
1632                         memcpy(network_access_name, open_channel_tlv->bearer_detail.ps_bearer.network_access_name.network_access_name, open_channel_tlv->bearer_detail.ps_bearer.network_access_name.length);
1633
1634                         other_addr_type = open_channel_tlv->bearer_detail.ps_bearer.other_address.address_type;
1635                         memcpy(other_address, open_channel_tlv->bearer_detail.ps_bearer.other_address.address, open_channel_tlv->bearer_detail.ps_bearer.other_address.address_len);
1636
1637                         tcore_util_convert_string_to_utf8((unsigned char*) &login, (unsigned short *) &login_len,
1638                                         open_channel_tlv->bearer_detail.ps_bearer.text_user_login.dcs.a_format,
1639                                         (unsigned char*) &open_channel_tlv->bearer_detail.ps_bearer.text_user_login.string,
1640                                         (unsigned short) open_channel_tlv->bearer_detail.ps_bearer.text_user_login.string_length);
1641
1642                         tcore_util_convert_string_to_utf8((unsigned char*) &pwd, (unsigned short *) &pwd_len,
1643                                         open_channel_tlv->bearer_detail.ps_bearer.text_user_pwd.dcs.a_format,
1644                                         (unsigned char*) &open_channel_tlv->bearer_detail.ps_bearer.text_user_pwd.string,
1645                                         (unsigned short) open_channel_tlv->bearer_detail.ps_bearer.text_user_pwd.string_length);
1646
1647                         bearer_detail= g_variant_new("(sisss)", network_access_name, other_addr_type, other_address, login, pwd);
1648
1649                 } break;
1650                 case BEARER_DEFAULT_BEARER_FROM_TRANSPORT_LAYER:{
1651                         //bearer param
1652
1653                         //bearer detail
1654                         gint other_addr_type = 0;
1655                         gint login_len = 0, pwd_len = 0;
1656                         gchar other_address[SAT_OTHER_ADDR_LEN_MAX];
1657                         gchar login[SAT_TEXT_STRING_LEN_MAX], pwd[SAT_TEXT_STRING_LEN_MAX];
1658
1659                         memset(&other_address, 0 , SAT_OTHER_ADDR_LEN_MAX);
1660                         memset(&login, 0 , SAT_TEXT_STRING_LEN_MAX);
1661                         memset(&pwd, 0 , SAT_TEXT_STRING_LEN_MAX);
1662
1663                         //bearer parameter
1664                         bearer_param = g_variant_new("()");
1665
1666                         other_addr_type = open_channel_tlv->bearer_detail.default_bearer.other_address.address_type;
1667                         memcpy(other_address, open_channel_tlv->bearer_detail.default_bearer.other_address.address, open_channel_tlv->bearer_detail.default_bearer.other_address.address_len);
1668
1669                         tcore_util_convert_string_to_utf8((unsigned char*) &login, (unsigned short *) &login_len,
1670                                         open_channel_tlv->bearer_detail.default_bearer.text_user_login.dcs.a_format,
1671                                         (unsigned char*) &open_channel_tlv->bearer_detail.default_bearer.text_user_login.string,
1672                                         (unsigned short) open_channel_tlv->bearer_detail.default_bearer.text_user_login.string_length);
1673
1674                         tcore_util_convert_string_to_utf8((unsigned char*) &pwd, (unsigned short *) &pwd_len,
1675                                         open_channel_tlv->bearer_detail.default_bearer.text_user_pwd.dcs.a_format,
1676                                         (unsigned char*) &open_channel_tlv->bearer_detail.default_bearer.text_user_pwd.string,
1677                                         (unsigned short) open_channel_tlv->bearer_detail.default_bearer.text_user_pwd.string_length);
1678
1679                         bearer_detail= g_variant_new("(isss)", other_addr_type, other_address, login, pwd);
1680
1681                 } break;
1682                 case BEARER_LOCAL_LINK_TECHNOLOGY_INDEPENDENT:{
1683                         //bearer param
1684
1685                         //bearer detail
1686                         gint pwd_len = 0;
1687                         gint remote_address_type =0, time_duration1 = 0, time_duration2 = 0;
1688                         gchar remote_address[SAT_REMOTE_ENTITY_ADDR_LEN_MAX];
1689                         gchar pwd[SAT_TEXT_STRING_LEN_MAX];
1690
1691                         memset(&remote_address, 0 , SAT_REMOTE_ENTITY_ADDR_LEN_MAX);
1692                         memset(&pwd, 0 , SAT_TEXT_STRING_LEN_MAX);
1693
1694                         //bearer parameter
1695                         bearer_param = g_variant_new("()");
1696
1697                         time_duration1 = _get_time_in_ms(&open_channel_tlv->bearer_detail.local_bearer.duration1);
1698                         time_duration2 = _get_time_in_ms(&open_channel_tlv->bearer_detail.local_bearer.duration2);
1699
1700                         tcore_util_convert_string_to_utf8((unsigned char*) &pwd, (unsigned short *) &pwd_len,
1701                                                                                         open_channel_tlv->bearer_detail.default_bearer.text_user_pwd.dcs.a_format,
1702                                                                                         (unsigned char*) &open_channel_tlv->bearer_detail.default_bearer.text_user_pwd.string,
1703                                                                                         (unsigned short) open_channel_tlv->bearer_detail.default_bearer.text_user_pwd.string_length);
1704
1705                         remote_address_type = open_channel_tlv->bearer_detail.local_bearer.remote_entity_address.coding_type;
1706                         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);
1707
1708                         bearer_detail= g_variant_new("(iisis)", time_duration1, time_duration2, pwd, remote_address_type, remote_address);
1709
1710                 } break;
1711                 default:
1712                         dbg("invalid bearer data");
1713                         return NULL;
1714         }//end of switch
1715
1716         //enqueue data and generate cmd_id
1717         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
1718         q_data.cmd_type = SAT_PROATV_CMD_OPEN_CHANNEL;
1719         memcpy((void*)&(q_data.cmd_data.open_channel), open_channel_tlv, sizeof(struct tel_sat_open_channel_tlv));
1720         sat_manager_enqueue_cmd(ctx, &q_data);
1721         command_id = q_data.cmd_id;
1722
1723         icon_id = g_variant_new("()");
1724
1725         //execute bip
1726         //sat_ui_support_exec_bip();
1727
1728         open_channel = g_variant_new("(isivbbbiviiiisv)", command_id, text, text_len, icon_id, immediate_link, auto_reconnection, bg_mode,
1729                         bearer_type, bearer_param, buffer_size, protocol_type, port_number, dest_addr_type, dest_address, bearer_detail);
1730
1731         return open_channel;
1732 }
1733
1734 GVariant* sat_manager_close_channel_noti(struct custom_data *ctx, const char *plugin_name, struct tel_sat_close_channel_tlv *close_channel_tlv)
1735 {
1736         TcorePlugin *plg = NULL;
1737         GVariant *close_channel = NULL;
1738         struct sat_manager_queue_data q_data;
1739
1740         gint command_id = 0, channel_id = 0;
1741         gint text_len = 0;
1742         gchar text[SAT_ALPHA_ID_LEN_MAX];
1743         GVariant *icon_id = NULL;
1744
1745         dbg("interpreting close channel notification");
1746         memset(&text, 0 , SAT_ALPHA_ID_LEN_MAX);
1747
1748         plg = tcore_server_find_plugin(ctx->server, plugin_name);
1749         if (!plg){
1750                 dbg("there is no valid plugin at this point");
1751                 return NULL;
1752         }
1753
1754         //channel id
1755         channel_id = close_channel_tlv->device_id.dest;
1756
1757         //close channel text
1758         if(close_channel_tlv->alpha_id.is_exist && close_channel_tlv->alpha_id.alpha_data_len > 0)
1759                 tcore_util_convert_string_to_utf8((unsigned char*)&text,(unsigned short *)&text_len,
1760                                 close_channel_tlv->alpha_id.dcs.a_format,
1761                                 (unsigned char*)&close_channel_tlv->alpha_id.alpha_data,
1762                                 (unsigned short)close_channel_tlv->alpha_id.alpha_data_len);
1763         dbg("close channel text(%s)",text);
1764
1765         //enqueue data and generate cmd_id
1766         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
1767         q_data.cmd_type = SAT_PROATV_CMD_CLOSE_CHANNEL;
1768         memcpy((void*)&(q_data.cmd_data.close_channel), close_channel_tlv, sizeof(struct tel_sat_close_channel_tlv));
1769         sat_manager_enqueue_cmd(ctx, &q_data);
1770         command_id = q_data.cmd_id;
1771
1772         icon_id = g_variant_new("()");
1773
1774         close_channel = g_variant_new("(isivi)", command_id, text, text_len, icon_id, channel_id);
1775
1776         return close_channel;
1777 }
1778
1779 GVariant* sat_manager_receive_data_noti(struct custom_data *ctx, const char *plugin_name, struct tel_sat_receive_channel_tlv *receive_data_tlv)
1780 {
1781         TcorePlugin *plg = NULL;
1782         GVariant *receive_data = NULL;
1783         struct sat_manager_queue_data q_data;
1784
1785         gint command_id = 0, channel_id = 0;
1786         gint text_len = 0, channel_data_len = 0;
1787         gchar text[SAT_ALPHA_ID_LEN_MAX];
1788         GVariant *icon_id = NULL;
1789
1790         dbg("interpreting receive data notification");
1791         memset(&text, 0 , SAT_ALPHA_ID_LEN_MAX);
1792
1793         plg = tcore_server_find_plugin(ctx->server, plugin_name);
1794         if (!plg){
1795                 dbg("there is no valid plugin at this point");
1796                 return NULL;
1797         }
1798
1799         //channel id
1800         channel_id = receive_data_tlv->device_id.dest;
1801
1802         //receive data text
1803         if(receive_data_tlv->alpha_id.is_exist && receive_data_tlv->alpha_id.alpha_data_len > 0)
1804                 tcore_util_convert_string_to_utf8((unsigned char*)&text,(unsigned short *)&text_len,
1805                                 receive_data_tlv->alpha_id.dcs.a_format,
1806                                 (unsigned char*)&receive_data_tlv->alpha_id.alpha_data,
1807                                 (unsigned short)receive_data_tlv->alpha_id.alpha_data_len);
1808         dbg("receive data text(%s)",text);
1809
1810         channel_data_len = receive_data_tlv->channel_data_len.data_len;
1811
1812         //enqueue data and generate cmd_id
1813         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
1814         q_data.cmd_type = SAT_PROATV_CMD_RECEIVE_DATA;
1815         memcpy((void*)&(q_data.cmd_data.receive_data), receive_data_tlv, sizeof(struct tel_sat_receive_channel_tlv));
1816         sat_manager_enqueue_cmd(ctx, &q_data);
1817         command_id = q_data.cmd_id;
1818
1819         icon_id = g_variant_new("()");
1820
1821         receive_data = g_variant_new("(isivii)", command_id, text, text_len, icon_id, channel_id, channel_data_len);
1822
1823         return receive_data;
1824 }
1825
1826 GVariant* sat_manager_send_data_noti(struct custom_data *ctx, const char *plugin_name, struct tel_sat_send_channel_tlv *send_data_tlv)
1827 {
1828         TcorePlugin *plg = NULL;
1829         GVariant *send_data = NULL;
1830         struct sat_manager_queue_data q_data;
1831
1832         int index = 0;
1833         gint command_id = 0, channel_id = 0, data_len = 0;
1834         gboolean send_data_immediately = FALSE;
1835         gint text_len = 0;
1836         gchar text[SAT_ALPHA_ID_LEN_MAX];
1837         GVariantBuilder *builder = NULL;
1838         GVariant *channel_data = NULL;
1839         GVariant *icon_id = NULL;
1840
1841         dbg("interpreting send data notification");
1842         memset(&text, 0 , SAT_ALPHA_ID_LEN_MAX);
1843
1844         plg = tcore_server_find_plugin(ctx->server, plugin_name);
1845         if (!plg){
1846                 dbg("there is no valid plugin at this point");
1847                 return NULL;
1848         }
1849
1850         //send data immediately
1851         send_data_immediately = send_data_tlv->command_detail.cmd_qualifier.send_data.send_data_immediately;
1852
1853         //channel id
1854         channel_id = send_data_tlv->device_id.dest;
1855
1856         //send data text
1857         if(send_data_tlv->alpha_id.is_exist && send_data_tlv->alpha_id.alpha_data_len > 0)
1858                 tcore_util_convert_string_to_utf8((unsigned char*)&text,(unsigned short *)&text_len,
1859                                 send_data_tlv->alpha_id.dcs.a_format,
1860                                 (unsigned char*)&send_data_tlv->alpha_id.alpha_data,
1861                                 (unsigned short)send_data_tlv->alpha_id.alpha_data_len);
1862         dbg("send data text(%s)",text);
1863
1864         //channel data, data len
1865         data_len = send_data_tlv->channel_data.data_string_len;
1866         builder = g_variant_builder_new(G_VARIANT_TYPE ("ay"));
1867         for (index = 0; index < data_len; index++) {
1868                 dbg("send data index(%d) data(0x%x)",index, send_data_tlv->channel_data.data_string[index]);
1869                 g_variant_builder_add(builder, "y", send_data_tlv->channel_data.data_string[index]);
1870         }
1871         channel_data = g_variant_builder_end(builder);
1872
1873         //enqueue data and generate cmd_id
1874         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
1875         q_data.cmd_type = SAT_PROATV_CMD_SEND_DATA;
1876         memcpy((void*)&(q_data.cmd_data.send_data), send_data_tlv, sizeof(struct tel_sat_send_channel_tlv));
1877         sat_manager_enqueue_cmd(ctx, &q_data);
1878         command_id = q_data.cmd_id;
1879
1880         icon_id = g_variant_new("()");
1881
1882         send_data = g_variant_new("(isivibvi)", command_id, text, text_len, icon_id, channel_id, send_data_immediately, channel_data, data_len);
1883
1884         return send_data;
1885 }
1886
1887 GVariant* sat_manager_get_channel_status_noti(struct custom_data *ctx, const char *plugin_name, struct tel_sat_get_channel_status_tlv *get_channel_status_tlv)
1888 {
1889         TcorePlugin *plg = NULL;
1890         GVariant *get_channel_status = NULL;
1891         struct sat_manager_queue_data q_data;
1892
1893         gint command_id = 0;
1894
1895         dbg("interpreting get channel status notification");
1896
1897         plg = tcore_server_find_plugin(ctx->server, plugin_name);
1898         if (!plg){
1899                 dbg("there is no valid plugin at this point");
1900                 return NULL;
1901         }
1902
1903         //enqueue data and generate cmd_id
1904         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
1905         q_data.cmd_type = SAT_PROATV_CMD_GET_CHANNEL_STATUS;
1906         memcpy((void*)&(q_data.cmd_data.get_channel_status), get_channel_status_tlv, sizeof(struct tel_sat_get_channel_status_tlv));
1907         sat_manager_enqueue_cmd(ctx, &q_data);
1908         command_id = q_data.cmd_id;
1909
1910         get_channel_status = g_variant_new("(i)", command_id);
1911
1912         return get_channel_status;
1913 }
1914
1915 GVariant* sat_manager_refresh_noti(struct custom_data *ctx, const char *plugin_name, struct tel_sat_refresh_tlv *refresh_tlv)
1916 {
1917         TcorePlugin *plg = NULL;
1918         GVariant *refresh = NULL;
1919         struct sat_manager_queue_data q_data;
1920
1921         gint command_id = 0;
1922         gint refresh_type =0;
1923         GVariantBuilder *builder = NULL;
1924         GVariant *file_list = NULL;
1925         int index = 0;
1926
1927         dbg("interpreting refresh notification");
1928
1929         plg = tcore_server_find_plugin(ctx->server, plugin_name);
1930         if (!plg){
1931                 dbg("there is no valid plugin at this point");
1932                 return NULL;
1933         }
1934
1935         refresh_type = refresh_tlv->command_detail.cmd_qualifier.refresh.refresh;
1936
1937         builder = g_variant_builder_new(G_VARIANT_TYPE ("ai"));
1938         for (index = 0; index < refresh_tlv->file_list.file_count; index++) {
1939                 g_variant_builder_add(builder, "i", refresh_tlv->file_list.file_id[index]);
1940         }
1941         file_list = g_variant_builder_end(builder);
1942
1943         //enqueue data and generate cmd_id
1944         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
1945         q_data.cmd_type = SAT_PROATV_CMD_REFRESH;
1946         memcpy((void*)&(q_data.cmd_data.refresh), refresh_tlv, sizeof(struct tel_sat_refresh_tlv));
1947         sat_manager_enqueue_cmd(ctx, &q_data);
1948         command_id = q_data.cmd_id;
1949
1950         refresh = g_variant_new("(iiv)", command_id, refresh_type, file_list);
1951
1952         return refresh;
1953 }
1954
1955 void sat_manager_more_time_noti(struct custom_data *ctx, const char *plugin_name, struct tel_sat_more_time_tlv *more_time_tlv)
1956 {
1957         TcorePlugin *plg = NULL;
1958         struct treq_sat_terminal_rsp_data *tr = NULL;
1959
1960         dbg("interpreting more time notification");
1961
1962         plg = tcore_server_find_plugin(ctx->server, plugin_name);
1963         if (!plg){
1964                 dbg("there is no valid plugin at this point");
1965                 return;
1966         }
1967         //send TR - does not need from application's response
1968         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
1969         tr->cmd_number = more_time_tlv->command_detail.cmd_num;
1970         tr->cmd_type = more_time_tlv->command_detail.cmd_type;
1971         memcpy((void*)&tr->terminal_rsp_data.more_time.command_detail, &more_time_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
1972         tr->terminal_rsp_data.more_time.device_id.src = more_time_tlv->device_id.dest;
1973         tr->terminal_rsp_data.more_time.device_id.dest = more_time_tlv->device_id.src;
1974         tr->terminal_rsp_data.more_time.result_type = RESULT_SUCCESS;
1975         tr->terminal_rsp_data.more_time.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
1976
1977         sat_manager_send_terminal_response(ctx->comm, plg, tr);
1978         g_free(tr);
1979
1980         return;
1981 }
1982
1983 GVariant* sat_manager_send_dtmf_noti(struct custom_data *ctx, const char *plugin_name, struct tel_sat_send_dtmf_tlv *send_dtmf_tlv)
1984 {
1985         TcorePlugin *plg = NULL;
1986         GVariant *send_dtmf = NULL;
1987         struct sat_manager_queue_data q_data;
1988
1989         gint command_id = 0;
1990         gint text_len =0, dtmf_str_len =0;
1991         gchar text[SAT_TEXT_STRING_LEN_MAX], dtmf_str[SAT_DTMF_STRING_LEN_MAX];
1992         GVariant *icon_id = NULL;
1993
1994         dbg("interpreting send dtmf notification");
1995         memset(&text, 0 , SAT_TEXT_STRING_LEN_MAX);
1996         memset(&dtmf_str, 0 , SAT_DTMF_STRING_LEN_MAX);
1997
1998         plg = tcore_server_find_plugin(ctx->server, plugin_name);
1999         if (!plg){
2000                 dbg("there is no valid plugin at this point");
2001                 return NULL;
2002         }
2003
2004         if( (send_dtmf_tlv->icon_id.is_exist) && ( send_dtmf_tlv->icon_id.icon_qualifer == ICON_QUALI_NOT_SELF_EXPLANATORY)
2005                         && (!send_dtmf_tlv->alpha_id.is_exist || !send_dtmf_tlv->alpha_id.alpha_data_len))
2006         {
2007                 struct treq_sat_terminal_rsp_data *tr = NULL;
2008                 dbg("[SAT]  exceptional case to fix gcf case 2.4 command not understood");
2009
2010                 tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
2011                 tr->cmd_number = send_dtmf_tlv->command_detail.cmd_num;
2012                 tr->cmd_type = send_dtmf_tlv->command_detail.cmd_type;
2013
2014                 memcpy((void*)&tr->terminal_rsp_data.send_dtmf.command_detail, &send_dtmf_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
2015                 tr->terminal_rsp_data.send_dtmf.device_id.src = send_dtmf_tlv->device_id.dest;
2016                 tr->terminal_rsp_data.send_dtmf.device_id.dest = send_dtmf_tlv->device_id.src;
2017                 tr->terminal_rsp_data.send_dtmf.result_type = RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME;
2018
2019                 sat_manager_send_terminal_response(ctx->comm, plg, tr);
2020                 g_free(tr);
2021
2022                 return NULL;
2023         }
2024
2025         //text and text len
2026         if( send_dtmf_tlv->alpha_id.is_exist && send_dtmf_tlv->alpha_id.alpha_data_len){
2027                 tcore_util_convert_string_to_utf8((unsigned char*)&text,(unsigned short *)&text_len,
2028                                 send_dtmf_tlv->alpha_id.dcs.a_format,
2029                                 (unsigned char*)&send_dtmf_tlv->alpha_id.alpha_data,
2030                                 (unsigned short)send_dtmf_tlv->alpha_id.alpha_data_len);
2031                 dbg("send dtmf ui display text (%s)",text);
2032         }
2033
2034         //dtmf string len, dtmf string
2035         dtmf_str_len = send_dtmf_tlv->dtmf_string.dtmf_length;
2036         memcpy(dtmf_str, send_dtmf_tlv->dtmf_string.dtmf_string, SAT_DTMF_STRING_LEN_MAX);
2037
2038         //enqueue data and generate cmd_id
2039         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
2040         q_data.cmd_type = SAT_PROATV_CMD_SEND_DTMF;
2041         memcpy((void*)&(q_data.cmd_data.send_dtmf), send_dtmf_tlv, sizeof(struct tel_sat_send_dtmf_tlv));
2042         sat_manager_enqueue_cmd(ctx, &q_data);
2043         command_id = q_data.cmd_id;
2044
2045         icon_id = g_variant_new("()");
2046
2047         send_dtmf = g_variant_new("(isivis)", command_id, text, text_len, icon_id,
2048                         dtmf_str_len, dtmf_str);
2049
2050         return send_dtmf;
2051 }
2052
2053 GVariant* sat_manager_launch_browser_noti(struct custom_data *ctx, const char *plugin_name, struct tel_sat_launch_browser_tlv *launch_browser_tlv)
2054 {
2055         TcorePlugin *plg = NULL;
2056         GVariant *launch_browser = NULL;
2057         struct sat_manager_queue_data q_data;
2058
2059         gint command_id = 0;
2060         gint browser_launch_type = 0, browser_id = 0;
2061         gint url_len =0, text_len =0, gateway_proxy_len =0;
2062         gchar url[SAT_URL_LEN_MAX], text[SAT_TEXT_STRING_LEN_MAX], gateway_proxy[SAT_TEXT_STRING_LEN_MAX];
2063         GVariant *icon_id = NULL;
2064
2065         dbg("interpreting launch browser notification");
2066         memset(&url, 0 , SAT_URL_LEN_MAX);
2067         memset(&text, 0 , SAT_TEXT_STRING_LEN_MAX);
2068         memset(&gateway_proxy, 0 , SAT_TEXT_STRING_LEN_MAX);
2069
2070         plg = tcore_server_find_plugin(ctx->server, plugin_name);
2071         if (!plg){
2072                 dbg("there is no valid plugin at this point");
2073                 return NULL;
2074         }
2075
2076         if( (launch_browser_tlv->user_confirm_icon_id.is_exist) && ( launch_browser_tlv->user_confirm_icon_id.icon_qualifer == ICON_QUALI_NOT_SELF_EXPLANATORY)
2077                         && (!launch_browser_tlv->user_confirm_alpha_id.is_exist || !launch_browser_tlv->user_confirm_alpha_id.alpha_data_len))
2078         {
2079                 struct treq_sat_terminal_rsp_data *tr = NULL;
2080                 dbg("[SAT]  exceptional case to fix gcf case 2.4 command not understood");
2081
2082                 tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
2083                 tr->cmd_number = launch_browser_tlv->command_detail.cmd_num;
2084                 tr->cmd_type = launch_browser_tlv->command_detail.cmd_type;
2085
2086                 memcpy((void*)&tr->terminal_rsp_data.launch_browser.command_detail, &launch_browser_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
2087                 tr->terminal_rsp_data.launch_browser.device_id.src = launch_browser_tlv->device_id.dest;
2088                 tr->terminal_rsp_data.launch_browser.device_id.dest = launch_browser_tlv->device_id.src;
2089                 tr->terminal_rsp_data.launch_browser.result_type = RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME;
2090
2091                 sat_manager_send_terminal_response(ctx->comm, plg, tr);
2092                 g_free(tr);
2093
2094                 return NULL;
2095         }
2096
2097         //browser launch type
2098         browser_launch_type = launch_browser_tlv->command_detail.cmd_qualifier.launch_browser.launch_browser;
2099
2100         //browser id
2101         browser_id = launch_browser_tlv->browser_id;
2102
2103         //url and url len
2104         if( launch_browser_tlv->url.url_length){
2105                 url_len = launch_browser_tlv->url.url_length;
2106                 memcpy(url, launch_browser_tlv->url.url, launch_browser_tlv->url.url_length);
2107                 dbg("launch browser url (%s)",url);
2108         }
2109
2110         //gateway_proxy_text
2111         if(launch_browser_tlv->gateway_proxy_text.is_digit_only) {
2112                 memcpy(gateway_proxy, launch_browser_tlv->gateway_proxy_text.string, launch_browser_tlv->gateway_proxy_text.string_length);
2113                 dbg("launch browser gateway_proxy digit type string (%s)",gateway_proxy);
2114         } else {
2115                 if( launch_browser_tlv->gateway_proxy_text.string_length){
2116                         tcore_util_convert_string_to_utf8((unsigned char*)&gateway_proxy,(unsigned short *)&gateway_proxy_len,
2117                                         launch_browser_tlv->gateway_proxy_text.dcs.a_format,
2118                                         (unsigned char*)&launch_browser_tlv->gateway_proxy_text.string,
2119                                         (unsigned short)launch_browser_tlv->gateway_proxy_text.string_length);
2120                         dbg("launch browser gateway_proxy_text (%s)",gateway_proxy);
2121                 }
2122         }
2123
2124         //user confirm text and user confirm text len
2125         if( launch_browser_tlv->user_confirm_alpha_id.is_exist && launch_browser_tlv->user_confirm_alpha_id.alpha_data_len){
2126                 tcore_util_convert_string_to_utf8((unsigned char*)&text,(unsigned short *)&text_len,
2127                                 launch_browser_tlv->user_confirm_alpha_id.dcs.a_format,
2128                                 (unsigned char*)&launch_browser_tlv->user_confirm_alpha_id.alpha_data,
2129                                 (unsigned short)launch_browser_tlv->user_confirm_alpha_id.alpha_data_len);
2130                 dbg("launch browser user confirm text (%s)",text);
2131         }
2132
2133         //enqueue data and generate cmd_id
2134         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
2135         q_data.cmd_type = SAT_PROATV_CMD_LAUNCH_BROWSER;
2136         memcpy((void*)&(q_data.cmd_data.launch_browser), launch_browser_tlv, sizeof(struct tel_sat_launch_browser_tlv));
2137         sat_manager_enqueue_cmd(ctx, &q_data);
2138         command_id = q_data.cmd_id;
2139
2140         icon_id = g_variant_new("()");
2141
2142         launch_browser = g_variant_new("(iiisisisiv)",
2143                         command_id, browser_launch_type, browser_id, url, url_len, gateway_proxy, gateway_proxy_len, text, text_len, icon_id);
2144
2145         return launch_browser;
2146 }
2147
2148 GVariant* sat_manager_provide_local_info_noti(struct custom_data *ctx, const char *plugin_name, struct tel_sat_provide_local_info_tlv *provide_local_info_tlv)
2149 {
2150         TcorePlugin *plg = NULL;
2151         GVariant *provide_info = NULL;
2152
2153         gint info_type =0;
2154         struct treq_sat_terminal_rsp_data *tr = NULL;
2155
2156         dbg("interpreting provide local info notification");
2157
2158         plg = tcore_server_find_plugin(ctx->server, plugin_name);
2159         if (!plg){
2160                 dbg("there is no valid plugin at this point");
2161                 return NULL;
2162         }
2163
2164         provide_info = g_variant_new("(i)", info_type);
2165
2166         //send TR - does not need from application's response
2167         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
2168         tr->cmd_number = provide_local_info_tlv->command_detail.cmd_num;
2169         tr->cmd_type = provide_local_info_tlv->command_detail.cmd_type;
2170         memcpy((void*)&tr->terminal_rsp_data.provide_local_info.command_detail, &provide_local_info_tlv->command_detail, sizeof(struct tel_sat_cmd_detail_info));
2171         tr->terminal_rsp_data.provide_local_info.device_id.src = provide_local_info_tlv->device_id.dest;
2172         tr->terminal_rsp_data.provide_local_info.device_id.dest = provide_local_info_tlv->device_id.src;
2173         tr->terminal_rsp_data.provide_local_info.other_info = TRUE;
2174
2175         info_type = provide_local_info_tlv->command_detail.cmd_qualifier.provide_local_info.provide_local_info;
2176
2177         switch(info_type){
2178                 case LOCAL_INFO_DATE_TIME_AND_TIMEZONE:{
2179                         int err = 0; int gmt = 0, n_flg = 0;
2180                         struct timezone c_tz;
2181                         struct timeval c_time;
2182
2183                         time_t time_val;
2184                         struct tm time_info;
2185
2186                         time(&time_val);
2187
2188                         tzset();
2189                         err = gettimeofday(&c_time, &c_tz);
2190                         localtime_r(&time_val, &time_info);
2191
2192                         //set the time information
2193                         tr->terminal_rsp_data.provide_local_info.other.date_time_and_timezone.year =
2194                                 _convert_decimal_to_bcd(time_info.tm_year+1900-2000);
2195
2196                         tr->terminal_rsp_data.provide_local_info.other.date_time_and_timezone.month =
2197                                         _convert_decimal_to_bcd(time_info.tm_mon+1);
2198
2199                         tr->terminal_rsp_data.provide_local_info.other.date_time_and_timezone.day =
2200                                         _convert_decimal_to_bcd(time_info.tm_mday);
2201
2202                         tr->terminal_rsp_data.provide_local_info.other.date_time_and_timezone.hour =
2203                                         _convert_decimal_to_bcd(time_info.tm_hour);
2204
2205                         tr->terminal_rsp_data.provide_local_info.other.date_time_and_timezone.minute =
2206                                         _convert_decimal_to_bcd(time_info.tm_min);
2207
2208                         tr->terminal_rsp_data.provide_local_info.other.date_time_and_timezone.second =
2209                                         _convert_decimal_to_bcd(time_info.tm_sec);
2210
2211                         gmt = c_tz.tz_minuteswest/60;
2212                         if(gmt < 0){
2213                                 gmt = gmt * -1;
2214                                 n_flg = 1;
2215                         }
2216
2217                         if(err != 0){
2218                                 tr->terminal_rsp_data.provide_local_info.other.date_time_and_timezone.timeZone = 0xFF;
2219                         }
2220                         else{
2221                                 tr->terminal_rsp_data.provide_local_info.other.date_time_and_timezone.timeZone =
2222                                         _convert_decimal_to_bcd(gmt);
2223
2224                                 if(n_flg == 1){
2225                                         tr->terminal_rsp_data.provide_local_info.other.date_time_and_timezone.timeZone += 0x80;
2226                                 }
2227
2228                                 if(time_info.tm_isdst > 0){
2229                                         tr->terminal_rsp_data.provide_local_info.other.date_time_and_timezone.timeZone += 0x40;
2230                                 }
2231                         }
2232
2233                         tr->terminal_rsp_data.provide_local_info.result_type = RESULT_SUCCESS;
2234                         tr->terminal_rsp_data.provide_local_info.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
2235                 } break;
2236                 case LOCAL_INFO_LANGUAGE:{
2237                         Server *s = NULL;
2238                         static Storage *strg;
2239                         gchar *lang_str = NULL;
2240                         enum tel_sim_language_type lang_type = SIM_LANG_UNSPECIFIED;
2241
2242                         tr->terminal_rsp_data.provide_local_info.result_type = RESULT_SUCCESS;
2243                         tr->terminal_rsp_data.provide_local_info.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
2244
2245                         s = ctx->server;
2246                         strg = tcore_server_find_storage(s, "vconf");
2247                         lang_str = tcore_storage_get_string(strg, STORAGE_KEY_LANGUAGE_SET);
2248                         if(lang_str)
2249                                 lang_type = _convert_string_to_sim_lang(lang_str);
2250
2251                         tr->terminal_rsp_data.provide_local_info.other.language = lang_type;
2252                 } break;
2253                 default :{
2254                         tr->terminal_rsp_data.provide_local_info.other_info = FALSE;
2255                         tr->terminal_rsp_data.provide_local_info.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
2256                         tr->terminal_rsp_data.provide_local_info.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
2257                 } break;
2258         }
2259
2260         sat_manager_send_terminal_response(ctx->comm, plg, tr);
2261         g_free(tr);
2262
2263         return provide_info;
2264 }
2265
2266 GVariant* sat_manager_language_notification_noti(struct custom_data *ctx, const char *plugin_name, struct tel_sat_language_notification_tlv *language_notification_tlv)
2267 {
2268         TcorePlugin *plg = NULL;
2269         GVariant *language_noti = NULL;
2270         struct sat_manager_queue_data q_data;
2271
2272         gint command_id = 0;
2273         gint language =0;
2274         gboolean b_specified = FALSE;
2275
2276         dbg("interpreting langauge notification");
2277
2278         plg = tcore_server_find_plugin(ctx->server, plugin_name);
2279         if (!plg){
2280                 dbg("there is no valid plugin at this point");
2281                 return NULL;
2282         }
2283
2284         if (language_notification_tlv->command_detail.cmd_qualifier.language_notification.specific_language == TRUE){
2285                 b_specified = TRUE;
2286                 language = language_notification_tlv->language;
2287         } else {
2288                 b_specified = FALSE;
2289                 language =SIM_LANG_UNSPECIFIED;
2290         }
2291
2292         //enqueue data and generate cmd_id
2293         memset(&q_data, 0x00, sizeof(struct sat_manager_queue_data));
2294         q_data.cmd_type = SAT_PROATV_CMD_LANGUAGE_NOTIFICATION;
2295         memcpy((void*)&(q_data.cmd_data.language_notification), language_notification_tlv, sizeof(struct tel_sat_language_notification_tlv));
2296         sat_manager_enqueue_cmd(ctx, &q_data);
2297         command_id = q_data.cmd_id;
2298
2299         language_noti = g_variant_new("(iib)", command_id, language, b_specified);
2300
2301         return language_noti;
2302 }
2303
2304 static gboolean _sat_manager_handle_setup_menu_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
2305 {
2306         TReturn rv = TCORE_RETURN_FAILURE;
2307         gboolean result = FALSE;
2308
2309         gint resp;
2310         struct treq_sat_terminal_rsp_data *tr;
2311         struct sat_manager_queue_data q_data;
2312
2313         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
2314
2315         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
2316                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
2317                 return result;
2318         }
2319
2320         if(!exec_result){
2321                 dbg("[SAT] setup menu result data is null");
2322                 return result;
2323         }
2324
2325         if (!plg){
2326                 dbg("there is no valid plugin at this point");
2327                 return result;
2328         }
2329
2330         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
2331         g_variant_get(exec_result, "(i)", &resp);
2332
2333         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
2334         tr->cmd_number = q_data.cmd_data.setupMenuInd.command_detail.cmd_num;
2335         tr->cmd_type = q_data.cmd_data.setupMenuInd.command_detail.cmd_type;
2336
2337         memcpy((void*)&tr->terminal_rsp_data.setup_menu.command_detail,
2338                 &q_data.cmd_data.setupMenuInd.command_detail, sizeof(struct tel_sat_cmd_detail_info));
2339
2340         tr->terminal_rsp_data.setup_menu.device_id.src = q_data.cmd_data.setupMenuInd.device_id.dest;
2341         tr->terminal_rsp_data.setup_menu.device_id.dest = q_data.cmd_data.setupMenuInd.device_id.src;
2342
2343         dbg("[SAT] Response: [0x%02x]", resp);
2344
2345         switch (resp) {
2346                 case RESULT_SUCCESS:
2347                         tr->terminal_rsp_data.setup_menu.result_type = RESULT_SUCCESS;
2348                         if (q_data.cmd_data.setupMenuInd.icon_id.icon_info.ics == IMAGE_CODING_SCHEME_COLOUR)
2349                                 tr->terminal_rsp_data.setup_menu.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
2350                         tr->terminal_rsp_data.setup_menu.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
2351                         break;
2352
2353                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
2354                         tr->terminal_rsp_data.setup_menu.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
2355                         tr->terminal_rsp_data.setup_menu.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
2356                         break;
2357
2358                 default:
2359                         //check the default case
2360                         tr->terminal_rsp_data.setup_menu.result_type = resp;
2361                         tr->terminal_rsp_data.setup_menu.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
2362                         dbg("[SAT] wrong result from app exec resp(%d)", resp);
2363                         break;
2364         }
2365
2366         result = TRUE;
2367         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
2368         if(rv != TCORE_RETURN_SUCCESS){
2369                 dbg("fail to send terminal response");
2370                 result = FALSE;
2371         }
2372
2373         g_free(tr);
2374
2375         return result;
2376 }
2377
2378 static gboolean _sat_manager_handle_display_text_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
2379 {
2380         TReturn rv = TCORE_RETURN_FAILURE;
2381         gboolean result = FALSE;
2382
2383         gint resp, me_problem;
2384         struct treq_sat_terminal_rsp_data *tr;
2385         struct sat_manager_queue_data q_data;
2386
2387         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
2388
2389         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
2390                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
2391                 return result;
2392         }
2393
2394         if(!exec_result){
2395                 dbg("[SAT] display text result data is null");
2396                 return result;
2397         }
2398
2399         if (!plg){
2400                 dbg("there is no valid plugin at this point");
2401                 return result;
2402         }
2403
2404         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
2405         g_variant_get(exec_result, "(ii)",&resp, &me_problem);
2406
2407         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
2408         tr->cmd_number = q_data.cmd_data.displayTextInd.command_detail.cmd_num;
2409         tr->cmd_type = q_data.cmd_data.displayTextInd.command_detail.cmd_type;
2410         memcpy((void*)&tr->terminal_rsp_data.display_text.command_detail, &q_data.cmd_data.displayTextInd.command_detail, sizeof(struct tel_sat_cmd_detail_info));
2411         tr->terminal_rsp_data.display_text.device_id.src = DEVICE_ID_ME;
2412         tr->terminal_rsp_data.display_text.device_id.dest = DEVICE_ID_SIM;
2413
2414         switch (resp) {
2415                 case RESULT_SUCCESS:
2416                         tr->terminal_rsp_data.display_text.result_type = RESULT_SUCCESS;
2417                         tr->terminal_rsp_data.display_text.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
2418                         break;
2419
2420                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
2421                         tr->terminal_rsp_data.display_text.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
2422                         tr->terminal_rsp_data.display_text.me_problem_type = me_problem;
2423                         break;
2424
2425                 default:
2426                         tr->terminal_rsp_data.display_text.result_type = resp;
2427                         tr->terminal_rsp_data.display_text.me_problem_type = me_problem;
2428                         dbg("[SAT] wrong result from app exec resp(%d) me_problem(%d)", resp, me_problem);
2429                         break;
2430         }
2431
2432         if (q_data.cmd_data.displayTextInd.icon_id.icon_info.ics == IMAGE_CODING_SCHEME_COLOUR)
2433                 tr->terminal_rsp_data.display_text.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
2434
2435         result = TRUE;
2436         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
2437         if(rv != TCORE_RETURN_SUCCESS){
2438                 dbg("fail to send terminal response");
2439                 result = FALSE;
2440         }
2441
2442         g_free(tr);
2443
2444         return result;
2445 }
2446
2447 static gboolean _sat_manager_handle_play_tone_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
2448 {
2449         TReturn rv = TCORE_RETURN_FAILURE;
2450         gboolean result = FALSE;
2451
2452         gint resp, me_problem;
2453         struct treq_sat_terminal_rsp_data *tr;
2454         struct sat_manager_queue_data q_data;
2455
2456         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
2457
2458         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
2459                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
2460                 return result;
2461         }
2462
2463         if(!exec_result){
2464                 dbg("[SAT] display text result data is null");
2465                 return result;
2466         }
2467
2468         if (!plg){
2469                 dbg("there is no valid plugin at this point");
2470                 return result;
2471         }
2472
2473         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
2474         g_variant_get(exec_result, "(ii)",&resp, &me_problem);
2475
2476         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
2477         tr->cmd_number = q_data.cmd_data.play_tone.command_detail.cmd_num;
2478         tr->cmd_type = q_data.cmd_data.play_tone.command_detail.cmd_type;
2479         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));
2480         tr->terminal_rsp_data.play_tone.device_id.src = DEVICE_ID_ME;
2481         tr->terminal_rsp_data.play_tone.device_id.dest = DEVICE_ID_SIM;
2482
2483         switch (resp) {
2484                 case RESULT_SUCCESS:
2485                         tr->terminal_rsp_data.play_tone.result_type = RESULT_SUCCESS;
2486                         if (q_data.cmd_data.play_tone.icon_id.icon_info.ics == IMAGE_CODING_SCHEME_COLOUR)
2487                                 tr->terminal_rsp_data.play_tone.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
2488
2489                         tr->terminal_rsp_data.play_tone.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
2490                         break;
2491
2492                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
2493                         tr->terminal_rsp_data.play_tone.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
2494                         tr->terminal_rsp_data.play_tone.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
2495                         break;
2496
2497                 case RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER:
2498                         tr->terminal_rsp_data.play_tone.result_type = RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER;
2499                         tr->terminal_rsp_data.play_tone.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
2500                         break;
2501
2502                 default:
2503                         tr->terminal_rsp_data.play_tone.result_type = resp;
2504                         tr->terminal_rsp_data.play_tone.me_problem_type = me_problem;
2505                         dbg("[SAT] wrong result from app exec resp(%d) me_problem(%d)", resp, me_problem);
2506                         break;
2507         }
2508
2509         if (q_data.cmd_data.displayTextInd.icon_id.icon_info.ics == IMAGE_CODING_SCHEME_COLOUR)
2510                 tr->terminal_rsp_data.display_text.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
2511
2512         result = TRUE;
2513         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
2514         if(rv != TCORE_RETURN_SUCCESS){
2515                 dbg("fail to send terminal response");
2516                 result = FALSE;
2517         }
2518
2519         g_free(tr);
2520         return result;
2521 }
2522
2523 static gboolean _sat_manager_handle_send_sms_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
2524 {
2525         TReturn rv = TCORE_RETURN_FAILURE;
2526         gboolean result = FALSE;
2527
2528         gint resp;
2529         struct treq_sat_terminal_rsp_data *tr;
2530         struct sat_manager_queue_data q_data;
2531
2532         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
2533
2534         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
2535                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
2536                 return result;
2537         }
2538
2539         if(!exec_result){
2540                 dbg("[SAT] send sms data is null");
2541                 return result;
2542         }
2543
2544         if (!plg){
2545                 dbg("there is no valid plugin at this point");
2546                 return result;
2547         }
2548
2549         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
2550         g_variant_get(exec_result, "(i)",&resp);
2551
2552         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
2553         tr->cmd_number = q_data.cmd_data.sendSMSInd.command_detail.cmd_num;
2554         tr->cmd_type = q_data.cmd_data.sendSMSInd.command_detail.cmd_type;
2555         memcpy((void*)&tr->terminal_rsp_data.send_sms.command_detail, &q_data.cmd_data.sendSMSInd.command_detail, sizeof(struct tel_sat_cmd_detail_info));
2556         tr->terminal_rsp_data.send_sms.device_id.src = DEVICE_ID_ME;
2557         tr->terminal_rsp_data.send_sms.device_id.dest = q_data.cmd_data.sendSMSInd.device_id.src;
2558
2559         switch (resp) {
2560                 case RESULT_SUCCESS:
2561                         tr->terminal_rsp_data.send_sms.result_type = RESULT_SUCCESS;
2562                         if (q_data.cmd_data.sendSMSInd.icon_id.icon_info.ics == IMAGE_CODING_SCHEME_COLOUR)
2563                                 tr->terminal_rsp_data.send_sms.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
2564
2565                         break;
2566
2567                 case RESULT_INTRCTN_WITH_CC_OR_SMS_CTRL_PRMNT_PRBLM:
2568                         tr->terminal_rsp_data.send_sms.result_type = RESULT_INTRCTN_WITH_CC_OR_SMS_CTRL_PRMNT_PRBLM;
2569                         tr->terminal_rsp_data.send_sms.cc_problem_type = CC_PROBLEM_ACTION_NOT_ALLOWED;
2570                         break;
2571
2572                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
2573                         tr->terminal_rsp_data.send_sms.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
2574                         tr->terminal_rsp_data.send_sms.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
2575                         break;
2576
2577                 case RESULT_BEYOND_ME_CAPABILITIES:
2578                         tr->terminal_rsp_data.send_sms.result_type = RESULT_BEYOND_ME_CAPABILITIES;
2579                         tr->terminal_rsp_data.send_sms.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
2580                         break;
2581
2582                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
2583                         tr->terminal_rsp_data.send_sms.result_type = RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME;
2584                         tr->terminal_rsp_data.send_sms.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
2585                         break;
2586
2587                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
2588                         tr->terminal_rsp_data.send_sms.result_type = RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME;
2589                         tr->terminal_rsp_data.send_sms.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
2590                         break;
2591
2592                 case RESULT_SMS_RP_ERROR:
2593                         tr->terminal_rsp_data.send_sms.result_type = RESULT_SMS_RP_ERROR;
2594                         tr->terminal_rsp_data.send_sms.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
2595                         break;
2596
2597                 default:
2598                         tr->terminal_rsp_data.send_sms.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
2599                         tr->terminal_rsp_data.send_sms.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
2600                         break;
2601         }
2602
2603         result = TRUE;
2604         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
2605         if(rv != TCORE_RETURN_SUCCESS){
2606                 dbg("fail to send terminal response");
2607                 result = FALSE;
2608         }
2609
2610         g_free(tr);
2611
2612 /*      if( q_data.cmd_data.sendSMSInd.alpha_id.alpha_data_len && q_data.cmd_data.sendSMSInd.alpha_id.is_exist)
2613                 sat_ui_support_terminate_sat_ui();*/
2614
2615         return result;
2616 }
2617
2618 static gboolean _sat_manager_handle_send_ss_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
2619 {
2620         TReturn rv = TCORE_RETURN_FAILURE;
2621         gboolean result = FALSE;
2622
2623         gint resp, me_problem, ss_cause, call_ctrl_problem, ss_str_len;
2624         gchar *ss_string;
2625         struct treq_sat_terminal_rsp_data *tr;
2626         struct sat_manager_queue_data q_data;
2627         //call ctrl action, result data object, text
2628
2629         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
2630
2631         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
2632                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
2633                 return result;
2634         }
2635
2636         if(!exec_result){
2637                 dbg("[SAT] send ss data is null");
2638                 return result;
2639         }
2640
2641         if (!plg){
2642                 dbg("there is no valid plugin at this point");
2643                 return result;
2644         }
2645
2646         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
2647         g_variant_get(exec_result, "(iiisii)", &resp, &me_problem, &ss_cause, &ss_string, &ss_str_len, &call_ctrl_problem);
2648
2649         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
2650         tr->cmd_number = q_data.cmd_data.send_ss.command_detail.cmd_num;
2651         tr->cmd_type = q_data.cmd_data.send_ss.command_detail.cmd_type;
2652         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));
2653         tr->terminal_rsp_data.send_ss.device_id.src = DEVICE_ID_ME;
2654         tr->terminal_rsp_data.send_ss.device_id.dest = q_data.cmd_data.send_ss.device_id.src;
2655
2656         switch (resp) {
2657                 case RESULT_SUCCESS:
2658                         tr->terminal_rsp_data.send_ss.result_type = RESULT_SUCCESS;
2659                         if (q_data.cmd_data.send_ss.icon_id.icon_info.ics == IMAGE_CODING_SCHEME_COLOUR)
2660                                 tr->terminal_rsp_data.send_ss.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
2661
2662                         if(ss_str_len > 0 && ss_string != NULL){
2663                                 memcpy(&tr->terminal_rsp_data.send_ss.text.dcs, &q_data.cmd_data.send_ss.alpha_id.dcs, sizeof(struct data_coding_scheme));
2664                                 memcpy((void*)tr->terminal_rsp_data.send_ss.text.string, ss_string, ss_str_len);
2665                                 tr->terminal_rsp_data.send_ss.text.string_length = ss_str_len;
2666                         }
2667                         break;
2668
2669                 case RESULT_SS_RETURN_ERROR:
2670                         tr->terminal_rsp_data.send_ss.result_type = RESULT_SS_RETURN_ERROR;
2671                         tr->terminal_rsp_data.send_ss.ss_problem = ss_cause;
2672                         break;
2673
2674                 case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
2675                         tr->terminal_rsp_data.send_ss.result_type = RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND;
2676                         tr->terminal_rsp_data.send_ss.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
2677                         break;
2678
2679                 default:
2680                         tr->terminal_rsp_data.send_ss.result_type = RESULT_SS_RETURN_ERROR;
2681                         tr->terminal_rsp_data.send_ss.ss_problem = SATK_SS_PROBLEM_NO_SPECIFIC_CAUSE;
2682                         break;
2683         }
2684
2685         result = TRUE;
2686         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
2687         if(rv != TCORE_RETURN_SUCCESS){
2688                 dbg("fail to send terminal response");
2689                 result = FALSE;
2690         }
2691         g_free(tr);
2692
2693         if( q_data.cmd_data.send_ss.alpha_id.alpha_data_len && q_data.cmd_data.send_ss.alpha_id.is_exist )
2694                 sat_ui_support_terminate_sat_ui();
2695
2696         return result;
2697 }
2698
2699 static gboolean _sat_manager_handle_send_ussd_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
2700 {
2701         TReturn rv = TCORE_RETURN_FAILURE;
2702         gboolean result = FALSE;
2703
2704         gint resp, me_problem, ss_cause, ussd_str_len;
2705         GVariant *ussd_str = NULL;
2706         struct treq_sat_terminal_rsp_data *tr;
2707         struct sat_manager_queue_data q_data;
2708         //call ctrl action, result data object, text, result2, text2
2709
2710         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
2711
2712         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
2713                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
2714                 return result;
2715         }
2716
2717         if(!exec_result){
2718                 dbg("[SAT] send ss data is null");
2719                 return result;
2720         }
2721
2722         if (!plg){
2723                 dbg("there is no valid plugin at this point");
2724                 return result;
2725         }
2726
2727         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
2728         g_variant_get(exec_result, "(iii@vi)", &resp, &me_problem, &ss_cause, &ussd_str, &ussd_str_len);
2729
2730         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
2731         tr->cmd_number = q_data.cmd_data.send_ussd.command_detail.cmd_num;
2732         tr->cmd_type = q_data.cmd_data.send_ussd.command_detail.cmd_type;
2733         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));
2734         tr->terminal_rsp_data.send_ussd.device_id.src = DEVICE_ID_ME;
2735         tr->terminal_rsp_data.send_ussd.device_id.dest = q_data.cmd_data.send_ussd.device_id.src;
2736
2737         switch (resp) {
2738                 case RESULT_SUCCESS:
2739                         tr->terminal_rsp_data.send_ussd.result_type = RESULT_SUCCESS;
2740                         if (q_data.cmd_data.send_ussd.icon_id.icon_info.ics == IMAGE_CODING_SCHEME_COLOUR)
2741                                 tr->terminal_rsp_data.send_ussd.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
2742
2743                         if(ussd_str_len > 0 && ussd_str){
2744                                 int index = 0;
2745                                 guchar data;
2746                                 GVariantIter *iter = NULL;
2747                                 GVariant *intermediate = NULL;
2748
2749                                 intermediate = g_variant_get_variant(ussd_str);
2750                                 dbg("ussd string format(%s)", g_variant_get_type_string(intermediate));
2751
2752                                 g_variant_get(intermediate, "ay", &iter);
2753                                 while( g_variant_iter_loop (iter, "y", &data)){
2754                                         dbg("index(%d) data(%c)", index, data);
2755
2756                                         if(index == 0){
2757                                                 tr->terminal_rsp_data.send_ussd.text.dcs.raw_dcs = (data & 0x0F);
2758                                         }
2759                                         else{
2760                                                 tr->terminal_rsp_data.send_ussd.text.string[index-1] = data;
2761                                         }
2762
2763                                         index++;
2764                                 }
2765                                 g_variant_iter_free(iter);
2766                                 g_variant_unref(intermediate);
2767
2768                                 tr->terminal_rsp_data.send_ussd.text.string_length = index-1;
2769                         }
2770                         break;
2771
2772                 case RESULT_SS_RETURN_ERROR:
2773                 case RESULT_USSD_RETURN_ERROR:
2774                         tr->terminal_rsp_data.send_ussd.result_type = RESULT_USSD_RETURN_ERROR;
2775                         tr->terminal_rsp_data.send_ussd.ussd_problem = ss_cause;
2776                         break;
2777
2778                 case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
2779                         tr->terminal_rsp_data.send_ussd.result_type = RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND;
2780                         tr->terminal_rsp_data.send_ussd.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
2781                         break;
2782
2783                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
2784                         tr->terminal_rsp_data.send_ussd.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
2785                         tr->terminal_rsp_data.send_ussd.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
2786                         break;
2787
2788                 default:
2789                         tr->terminal_rsp_data.send_ussd.result_type = RESULT_USSD_RETURN_ERROR;
2790                         tr->terminal_rsp_data.send_ussd.ussd_problem = SATK_USSD_PROBLEM_NO_SPECIFIC_CAUSE;
2791                         break;
2792         }
2793
2794         result = TRUE;
2795         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
2796         if(rv != TCORE_RETURN_SUCCESS){
2797                 dbg("fail to send terminal response");
2798                 result = FALSE;
2799         }
2800         g_free(tr);
2801
2802         if( q_data.cmd_data.send_ussd.alpha_id.alpha_data_len && q_data.cmd_data.send_ussd.alpha_id.is_exist )
2803                 sat_ui_support_terminate_sat_ui();
2804
2805         return result;
2806 }
2807
2808 static gboolean _sat_manager_handle_setup_call_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
2809 {
2810         TReturn rv = TCORE_RETURN_FAILURE;
2811         gboolean result = FALSE;
2812
2813         gint resp, me_problem, cc_problem, call_cause;
2814         struct treq_sat_terminal_rsp_data *tr;
2815         struct sat_manager_queue_data q_data;
2816
2817         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
2818
2819         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
2820                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
2821                 return result;
2822         }
2823
2824         if(!exec_result){
2825                 dbg("[SAT] setup call data is null");
2826                 return result;
2827         }
2828
2829         if (!plg){
2830                 dbg("there is no valid plugin at this point");
2831                 return result;
2832         }
2833
2834         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
2835         g_variant_get(exec_result, "(iiii)",&resp, &me_problem, &cc_problem, &call_cause);
2836
2837         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
2838         tr->cmd_number = q_data.cmd_data.setup_call.command_detail.cmd_num;
2839         tr->cmd_type = q_data.cmd_data.setup_call.command_detail.cmd_type;
2840         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));
2841         tr->terminal_rsp_data.setup_call.device_id.src = DEVICE_ID_ME;
2842         tr->terminal_rsp_data.setup_call.device_id.dest = q_data.cmd_data.setup_call.device_id.src;
2843
2844         switch (resp) {
2845                 case RESULT_SUCCESS:
2846                         tr->terminal_rsp_data.setup_call.result_type = RESULT_SUCCESS;
2847                         if (q_data.cmd_data.setup_call.call_setup_icon_id.icon_info.ics == IMAGE_CODING_SCHEME_COLOUR)
2848                                 tr->terminal_rsp_data.setup_call.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
2849                         tr->terminal_rsp_data.setup_call.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
2850                         tr->terminal_rsp_data.setup_call.cc_problem_type = CC_PROBLEM_NO_SPECIFIC_CAUSE;
2851                         break;
2852
2853                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
2854                         tr->terminal_rsp_data.setup_call.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
2855                         tr->terminal_rsp_data.setup_call.me_problem_type = me_problem;
2856                         break;
2857
2858                 case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:{
2859                         tr->terminal_rsp_data.setup_call.result_type = RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND;
2860                         switch(call_cause){
2861                                 case CALL_ERROR_BUSY:
2862                                         tr->terminal_rsp_data.setup_call.network_problem_type = NETWORK_PROBLEM_USER_BUSY;
2863                                 break;
2864                                 default :
2865                                         tr->terminal_rsp_data.setup_call.network_problem_type = NETWORK_PROBLEM_NO_SPECIFIC_CAUSE;
2866                                 break;
2867                         }
2868                 }break;
2869
2870                 case RESULT_USER_CLEAR_DOWN_CALL_BEFORE_CONN:
2871                         tr->terminal_rsp_data.setup_call.result_type = RESULT_USER_CLEAR_DOWN_CALL_BEFORE_CONN;
2872                         tr->terminal_rsp_data.setup_call.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
2873                         tr->terminal_rsp_data.setup_call.cc_problem_type = CC_PROBLEM_NO_SPECIFIC_CAUSE;
2874                         break;
2875
2876                 case RESULT_BEYOND_ME_CAPABILITIES:
2877                         tr->terminal_rsp_data.setup_call.result_type = RESULT_BEYOND_ME_CAPABILITIES;
2878                         tr->terminal_rsp_data.setup_call.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
2879                         tr->terminal_rsp_data.setup_call.cc_problem_type = CC_PROBLEM_NO_SPECIFIC_CAUSE;
2880                         break;
2881
2882                 case RESULT_INTRCTN_WITH_CC_OR_SMS_CTRL_PRMNT_PRBLM:
2883                         tr->terminal_rsp_data.setup_call.result_type = RESULT_INTRCTN_WITH_CC_OR_SMS_CTRL_PRMNT_PRBLM;
2884                         tr->terminal_rsp_data.setup_call.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
2885                         tr->terminal_rsp_data.setup_call.cc_problem_type = cc_problem;
2886                         break;
2887
2888
2889                 default:
2890                         break;
2891         }
2892
2893         //TODO Other infomation set - not supported
2894         tr->terminal_rsp_data.setup_call.other_info = FALSE;
2895
2896         result = TRUE;
2897         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
2898         if(rv != TCORE_RETURN_SUCCESS){
2899                 dbg("fail to send terminal response");
2900                 result = FALSE;
2901         }
2902
2903         g_free(tr);
2904         return result;
2905 }
2906
2907 static gboolean _sat_manager_handle_setup_idle_mode_text_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
2908 {
2909         TReturn rv = TCORE_RETURN_FAILURE;
2910         gboolean result = FALSE;
2911
2912         gint resp, me_problem;
2913         struct treq_sat_terminal_rsp_data *tr;
2914         struct sat_manager_queue_data q_data;
2915
2916         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
2917
2918         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
2919                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
2920                 return result;
2921         }
2922
2923         if(!exec_result){
2924                 dbg("[SAT] send ss data is null");
2925                 return result;
2926         }
2927
2928         if (!plg){
2929                 dbg("there is no valid plugin at this point");
2930                 return result;
2931         }
2932
2933         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
2934         g_variant_get(exec_result, "(ii)",&resp, &me_problem);
2935
2936         tr = g_new0(struct treq_sat_terminal_rsp_data, 1);
2937         tr->cmd_number = q_data.cmd_data.idle_mode.command_detail.cmd_num;
2938         tr->cmd_type = q_data.cmd_data.idle_mode.command_detail.cmd_type;
2939         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));
2940         tr->terminal_rsp_data.setup_idle_mode_text.device_id.src = q_data.cmd_data.idle_mode.device_id.dest;
2941         tr->terminal_rsp_data.setup_idle_mode_text.device_id.dest = q_data.cmd_data.idle_mode.device_id.src;
2942
2943         switch (resp) {
2944                 case RESULT_SUCCESS:
2945                         tr->terminal_rsp_data.setup_idle_mode_text.result_type = RESULT_SUCCESS;
2946                         if (q_data.cmd_data.idle_mode.icon_id.icon_info.ics == IMAGE_CODING_SCHEME_COLOUR)
2947                                 tr->terminal_rsp_data.setup_idle_mode_text.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
2948
2949                         break;
2950                 default:
2951                         tr->terminal_rsp_data.setup_idle_mode_text.result_type = resp;
2952                         tr->terminal_rsp_data.setup_idle_mode_text.me_problem_type = me_problem;
2953                         break;
2954         }
2955
2956         result = TRUE;
2957         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
2958         if(rv != TCORE_RETURN_SUCCESS){
2959                 dbg("fail to send terminal response");
2960                 result = FALSE;
2961         }
2962         g_free(tr);
2963
2964         sat_ui_support_terminate_sat_ui();
2965
2966         return result;
2967 }
2968
2969 static gboolean sat_manager_handle_open_channel_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
2970 {
2971         TReturn rv = TCORE_RETURN_FAILURE;
2972         gboolean result = FALSE;
2973
2974         gint resp, me_problem, bip_problem;
2975         gint bearer_type, channel_id, channel_status, channel_status_info, buffer_size;
2976         gboolean other_info;
2977         GVariant *desc_tmp, *bearer_desc;
2978
2979         struct treq_sat_terminal_rsp_data *tr;
2980         struct sat_manager_queue_data q_data;
2981
2982         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
2983
2984         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
2985                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
2986                 return result;
2987         }
2988
2989         if(!exec_result){
2990                 dbg("[SAT] open channel data is null");
2991                 return result;
2992         }
2993
2994         if (!plg){
2995                 dbg("there is no valid plugin at this point");
2996                 return result;
2997         }
2998
2999         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
3000         g_variant_get(exec_result, "(iiiiiiiibv)",&resp, &me_problem, &bip_problem,
3001                         &bearer_type, &channel_id, &channel_status, &channel_status_info, &buffer_size,
3002                         &other_info, &desc_tmp);
3003
3004         bearer_desc = g_variant_get_variant(desc_tmp);
3005
3006         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
3007         tr->cmd_number = q_data.cmd_data.open_channel.command_detail.cmd_num;
3008         tr->cmd_type = q_data.cmd_data.open_channel.command_detail.cmd_type;
3009         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));
3010
3011         tr->terminal_rsp_data.open_channel.device_id.src = q_data.cmd_data.open_channel.device_id.dest;
3012         tr->terminal_rsp_data.open_channel.device_id.dest = q_data.cmd_data.open_channel.device_id.src;
3013
3014         tr->terminal_rsp_data.open_channel.result_type = resp;
3015         switch (resp) {
3016                 case RESULT_SUCCESS:
3017                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
3018                 case RESULT_SUCCESS_WITH_MISSING_INFO:
3019                         //channel status
3020                         break;
3021
3022                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
3023                 case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
3024                         tr->terminal_rsp_data.open_channel.me_problem_type = me_problem;
3025                         break;
3026
3027                 case RESULT_BEARER_INDEPENDENT_PROTOCOL_ERROR:
3028                         tr->terminal_rsp_data.open_channel.bip_problem_type = bip_problem;
3029                         break;
3030
3031                 default:
3032                         break;
3033         }
3034
3035         tr->terminal_rsp_data.open_channel.channel_status.channel_id = channel_id;
3036         tr->terminal_rsp_data.open_channel.channel_status.status = channel_status;
3037         tr->terminal_rsp_data.open_channel.channel_status.status_info = channel_status_info;
3038
3039         dbg("check channel id(%d) channel status(%d) channel info(%d)", channel_id, channel_status, channel_status_info);
3040
3041         //memcpy(tr->terminal_rsp_data.open_channel.buffer_size.size, &buffer_size, sizeof(unsigned char)*2);
3042         tr->terminal_rsp_data.open_channel.buffer_size.size[0] = buffer_size >> 8;
3043         tr->terminal_rsp_data.open_channel.buffer_size.size[1] = buffer_size & 0xFF;
3044         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]);
3045
3046         tr->terminal_rsp_data.open_channel.bearer_desc.bearer_type = bearer_type;
3047         switch(bearer_type){
3048                 case BEARER_CSD:{
3049                         gint data_rate, service_type, conn_element_type;
3050
3051                         dbg("bearer_desc cs bearer type_format(%s)", g_variant_get_type_string(bearer_desc));
3052                         g_variant_get(bearer_desc, "(iii)",&data_rate, &service_type, &conn_element_type);
3053                         dbg("check cs bearer data_rade(%d), service_type(%d), conn_element_type(%d)", data_rate, service_type, conn_element_type);
3054
3055                         tr->terminal_rsp_data.open_channel.bearer_desc.bearer_parameter.cs_bearer_param.data_rate = data_rate;
3056                         tr->terminal_rsp_data.open_channel.bearer_desc.bearer_parameter.cs_bearer_param.service_type = service_type;
3057                         tr->terminal_rsp_data.open_channel.bearer_desc.bearer_parameter.cs_bearer_param.connection_element_type = conn_element_type;
3058                 }break;
3059                 case BEARER_GPRS:{
3060                         gint precedence_class, delay_class, reliability_class;
3061                         gint peak_class, mean_class, pdp_type;
3062
3063                         dbg("bearer_desc ps bearer type_format(%s)", g_variant_get_type_string(bearer_desc));
3064                         g_variant_get(bearer_desc, "(iiiiii)",&precedence_class, &delay_class, &reliability_class,
3065                                         &peak_class, &mean_class, &pdp_type);
3066                         dbg("check ps bearer precedence class(%d), delay class(%d), reliability class(%d) peak class(%d) mean class(%d) pdp_type(%d)",
3067                                         precedence_class, delay_class, reliability_class, peak_class, mean_class, pdp_type);
3068
3069                         tr->terminal_rsp_data.open_channel.bearer_desc.bearer_parameter.ps_bearer_param.precedence_class = precedence_class;
3070                         tr->terminal_rsp_data.open_channel.bearer_desc.bearer_parameter.ps_bearer_param.delay_class = delay_class;
3071                         tr->terminal_rsp_data.open_channel.bearer_desc.bearer_parameter.ps_bearer_param.reliability_class = reliability_class;
3072                         tr->terminal_rsp_data.open_channel.bearer_desc.bearer_parameter.ps_bearer_param.peak_throughput_class = peak_class;
3073                         tr->terminal_rsp_data.open_channel.bearer_desc.bearer_parameter.ps_bearer_param.mean_throughput_class = mean_class;
3074                         tr->terminal_rsp_data.open_channel.bearer_desc.bearer_parameter.ps_bearer_param.pdp_type = pdp_type;
3075                 }break;
3076                 case BEARER_LOCAL_LINK_TECHNOLOGY_INDEPENDENT:{
3077                         gint service_type;
3078                         gchar *service_record = NULL;
3079
3080                         dbg("bearer_desc link local type_format(%s)", g_variant_get_type_string(bearer_desc));
3081                         g_variant_get(bearer_desc, "(is)",&service_type, &service_record);
3082                         dbg("check link local service_type(%d), service_record(%d)", service_type, service_record);
3083
3084                         tr->terminal_rsp_data.open_channel.bearer_desc.bearer_parameter.local_link_bearer_param.service_type = service_type;
3085
3086                         if(service_record)
3087                                 memcpy(tr->terminal_rsp_data.open_channel.bearer_desc.bearer_parameter.local_link_bearer_param.service_record, service_record, strlen(service_record));
3088
3089                 }break;
3090                 default:
3091                 break;
3092         }
3093
3094         result = TRUE;
3095         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
3096         if(rv != TCORE_RETURN_SUCCESS){
3097                 dbg("fail to send terminal response");
3098                 result = FALSE;
3099         }
3100
3101         g_free(tr);
3102         return result;
3103 }
3104
3105 static gboolean sat_manager_handle_close_channel_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
3106 {
3107         TReturn rv = TCORE_RETURN_FAILURE;
3108         gboolean result = FALSE;
3109
3110         gint resp, me_problem, bip_problem;
3111
3112         struct treq_sat_terminal_rsp_data *tr;
3113         struct sat_manager_queue_data q_data;
3114
3115         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
3116
3117         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
3118                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
3119                 return result;
3120         }
3121
3122         if(!exec_result){
3123                 dbg("[SAT] close channel data is null");
3124                 return result;
3125         }
3126
3127         if (!plg){
3128                 dbg("there is no valid plugin at this point");
3129                 return result;
3130         }
3131
3132         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
3133         g_variant_get(exec_result, "(iii)",&resp, &me_problem, &bip_problem);
3134
3135         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
3136         tr->cmd_number = q_data.cmd_data.close_channel.command_detail.cmd_num;
3137         tr->cmd_type = q_data.cmd_data.close_channel.command_detail.cmd_type;
3138         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));
3139
3140         tr->terminal_rsp_data.close_channel.device_id.src = DEVICE_ID_ME;
3141         tr->terminal_rsp_data.close_channel.device_id.dest = q_data.cmd_data.close_channel.device_id.src;
3142
3143         tr->terminal_rsp_data.close_channel.result_type = resp;
3144         switch (resp) {
3145                 case RESULT_SUCCESS:
3146                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
3147                 case RESULT_SUCCESS_WITH_MISSING_INFO:
3148                         //channel status
3149                         break;
3150
3151                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
3152                 case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
3153                         tr->terminal_rsp_data.close_channel.me_problem_type = me_problem;
3154                         break;
3155
3156                 case RESULT_BEARER_INDEPENDENT_PROTOCOL_ERROR:
3157                         tr->terminal_rsp_data.close_channel.bip_problem_type = bip_problem;
3158                         break;
3159
3160                 default:
3161                         break;
3162         }
3163
3164         result = TRUE;
3165         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
3166         if(rv != TCORE_RETURN_SUCCESS){
3167                 dbg("fail to send terminal response");
3168                 result = FALSE;
3169         }
3170
3171         g_free(tr);
3172         return result;
3173 }
3174
3175 static gboolean sat_manager_handle_receive_data_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
3176 {
3177         TReturn rv = TCORE_RETURN_FAILURE;
3178         gboolean result = FALSE;
3179
3180         gint resp, me_problem, bip_problem;
3181         gint data_str_len, data_len;
3182         gboolean other_info;
3183         GVariant *received_data;
3184
3185         struct treq_sat_terminal_rsp_data *tr;
3186         struct sat_manager_queue_data q_data;
3187
3188         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
3189
3190         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
3191                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
3192                 return result;
3193         }
3194
3195         if(!exec_result){
3196                 dbg("[SAT] receive data data is null");
3197                 return result;
3198         }
3199
3200         if (!plg){
3201                 dbg("there is no valid plugin at this point");
3202                 return result;
3203         }
3204
3205         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
3206         g_variant_get(exec_result, "(iiiiibv)",&resp, &me_problem, &bip_problem, &data_str_len, &data_len, &other_info, &received_data);
3207
3208         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
3209         tr->cmd_number = q_data.cmd_data.receive_data.command_detail.cmd_num;
3210         tr->cmd_type = q_data.cmd_data.receive_data.command_detail.cmd_type;
3211         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));
3212
3213         tr->terminal_rsp_data.receive_data.device_id.src = DEVICE_ID_ME;
3214         tr->terminal_rsp_data.receive_data.device_id.dest = q_data.cmd_data.receive_data.device_id.src;
3215
3216         tr->terminal_rsp_data.receive_data.result_type = resp;
3217         switch (resp) {
3218                 case RESULT_SUCCESS:
3219                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
3220                 case RESULT_SUCCESS_WITH_MISSING_INFO:
3221                         //channel status
3222                         break;
3223
3224                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
3225                 case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
3226                         tr->terminal_rsp_data.receive_data.me_problem_type = me_problem;
3227                         break;
3228
3229                 case RESULT_BEARER_INDEPENDENT_PROTOCOL_ERROR:
3230                         tr->terminal_rsp_data.receive_data.bip_problem_type = bip_problem;
3231                         break;
3232
3233                 default:
3234                         break;
3235         }
3236
3237         tr->terminal_rsp_data.receive_data.channel_data_len.data_len = data_len;
3238         tr->terminal_rsp_data.receive_data.channel_data.data_string_len = data_str_len;
3239
3240         if(received_data){
3241                 int index = 0;
3242                 guchar data;
3243                 GVariantIter *iter = NULL;
3244
3245                 dbg("additional data exist type_format(%s)", g_variant_get_type_string(received_data));
3246
3247                 g_variant_get(received_data, "ay", &iter);
3248                 while( g_variant_iter_loop (iter, "y", &data)){
3249                         dbg("index(%d) data(%d)", index, data);
3250                         tr->terminal_rsp_data.receive_data.channel_data.data_string[index] = data;
3251                         index++;
3252                 }
3253                 g_variant_iter_free(iter);
3254
3255                 dbg("the last index data(%d), data_total_len(%d)", index, data_str_len);
3256         }
3257
3258         result = TRUE;
3259         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
3260         if(rv != TCORE_RETURN_SUCCESS){
3261                 dbg("fail to send terminal response");
3262                 result = FALSE;
3263         }
3264
3265         g_free(tr);
3266         return result;
3267 }
3268
3269 static gboolean sat_manager_handle_send_data_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
3270 {
3271         TReturn rv = TCORE_RETURN_FAILURE;
3272         gboolean result = FALSE;
3273
3274         gint resp, me_problem, bip_problem;
3275         gint data_len;
3276
3277         struct treq_sat_terminal_rsp_data *tr;
3278         struct sat_manager_queue_data q_data;
3279
3280         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
3281
3282         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
3283                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
3284                 return result;
3285         }
3286
3287         if(!exec_result){
3288                 dbg("[SAT] send data data is null");
3289                 return result;
3290         }
3291
3292         if (!plg){
3293                 dbg("there is no valid plugin at this point");
3294                 return result;
3295         }
3296
3297         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
3298         g_variant_get(exec_result, "(iiii)",&resp, &me_problem, &bip_problem, &data_len);
3299
3300         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
3301         tr->cmd_number = q_data.cmd_data.send_data.command_detail.cmd_num;
3302         tr->cmd_type = q_data.cmd_data.send_data.command_detail.cmd_type;
3303         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));
3304
3305         tr->terminal_rsp_data.send_data.device_id.src = DEVICE_ID_ME;
3306         tr->terminal_rsp_data.send_data.device_id.dest = q_data.cmd_data.send_data.device_id.src;
3307
3308         tr->terminal_rsp_data.send_data.result_type = resp;
3309         switch (resp) {
3310                 case RESULT_SUCCESS:
3311                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
3312                 case RESULT_SUCCESS_WITH_MISSING_INFO:
3313                         //channel status
3314                         break;
3315
3316                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
3317                 case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
3318                         tr->terminal_rsp_data.send_data.me_problem_type = me_problem;
3319                         break;
3320
3321                 case RESULT_BEARER_INDEPENDENT_PROTOCOL_ERROR:
3322                         tr->terminal_rsp_data.send_data.bip_problem_type = bip_problem;
3323                         break;
3324
3325                 default:
3326                         break;
3327         }
3328
3329         tr->terminal_rsp_data.send_data.channel_data_len.data_len = data_len;
3330
3331         result = TRUE;
3332         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
3333         if(rv != TCORE_RETURN_SUCCESS){
3334                 dbg("fail to send terminal response");
3335                 result = FALSE;
3336         }
3337
3338         g_free(tr);
3339         return result;
3340 }
3341
3342 static gboolean sat_manager_handle_get_channel_status_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
3343 {
3344         TReturn rv = TCORE_RETURN_FAILURE;
3345         gboolean result = FALSE;
3346
3347         gint resp, me_problem, bip_problem;
3348         gint channel_id, channel_status, channel_status_info;
3349
3350         struct treq_sat_terminal_rsp_data *tr;
3351         struct sat_manager_queue_data q_data;
3352
3353         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
3354
3355         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
3356                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
3357                 return result;
3358         }
3359
3360         if(!exec_result){
3361                 dbg("[SAT] get channel status data is null");
3362                 return result;
3363         }
3364
3365         if (!plg){
3366                 dbg("there is no valid plugin at this point");
3367                 return result;
3368         }
3369
3370         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
3371         g_variant_get(exec_result, "(iiiiii)",&resp, &me_problem, &bip_problem,
3372                         &channel_id, &channel_status, &channel_status_info);
3373
3374         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
3375         tr->cmd_number = q_data.cmd_data.get_channel_status.command_detail.cmd_num;
3376         tr->cmd_type = q_data.cmd_data.get_channel_status.command_detail.cmd_type;
3377         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));
3378
3379         tr->terminal_rsp_data.get_channel_status.device_id.src = q_data.cmd_data.get_channel_status.device_id.dest;
3380         tr->terminal_rsp_data.get_channel_status.device_id.dest = q_data.cmd_data.get_channel_status.device_id.src;
3381
3382         tr->terminal_rsp_data.get_channel_status.result_type = resp;
3383         switch (resp) {
3384                 case RESULT_SUCCESS:
3385                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
3386                 case RESULT_SUCCESS_WITH_MISSING_INFO:
3387                         //channel status
3388                         break;
3389
3390                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
3391                 case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
3392                         tr->terminal_rsp_data.get_channel_status.me_problem_type = me_problem;
3393                         break;
3394
3395                 case RESULT_BEARER_INDEPENDENT_PROTOCOL_ERROR:
3396                         tr->terminal_rsp_data.get_channel_status.bip_problem_type = bip_problem;
3397                         break;
3398
3399                 default:
3400                         break;
3401         }
3402
3403         tr->terminal_rsp_data.get_channel_status.channel_status.channel_id = channel_id;
3404         tr->terminal_rsp_data.get_channel_status.channel_status.status = channel_status;
3405         tr->terminal_rsp_data.get_channel_status.channel_status.status_info = channel_status_info;
3406
3407         result = TRUE;
3408         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
3409         if(rv != TCORE_RETURN_SUCCESS){
3410                 dbg("fail to send terminal response");
3411                 result = FALSE;
3412         }
3413
3414         g_free(tr);
3415         return result;
3416 }
3417
3418 static gboolean sat_manager_handle_send_dtmf_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
3419 {
3420         TReturn rv = TCORE_RETURN_FAILURE;
3421         gboolean result = FALSE;
3422
3423         gint resp;
3424         struct treq_sat_terminal_rsp_data *tr;
3425         struct sat_manager_queue_data q_data;
3426
3427         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
3428         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
3429
3430         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
3431                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
3432                 g_free(tr);
3433                 return result;
3434         }
3435
3436         if(!exec_result){
3437                 dbg("[SAT] get channel status data is null");
3438                 g_free(tr);
3439                 return result;
3440         }
3441
3442         if (!plg){
3443                 dbg("there is no valid plugin at this point");
3444                 g_free(tr);
3445                 return result;
3446         }
3447
3448         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
3449         g_variant_get(exec_result, "(i)",&resp);
3450
3451         tr->cmd_number = q_data.cmd_data.send_dtmf.command_detail.cmd_num;
3452         tr->cmd_type = q_data.cmd_data.send_dtmf.command_detail.cmd_type;
3453         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));
3454
3455         tr->terminal_rsp_data.send_dtmf.device_id.src = DEVICE_ID_ME;
3456         tr->terminal_rsp_data.send_dtmf.device_id.dest = q_data.cmd_data.send_dtmf.device_id.src;
3457
3458         tr->terminal_rsp_data.send_dtmf.result_type = resp;
3459         switch (resp) {
3460                 case RESULT_SUCCESS:
3461                         if (q_data.cmd_data.send_dtmf.icon_id.icon_info.ics == IMAGE_CODING_SCHEME_COLOUR)
3462                                 tr->terminal_rsp_data.send_dtmf.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
3463                         break;
3464
3465                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
3466                         tr->terminal_rsp_data.send_dtmf.me_problem_type = ME_PROBLEM_NOT_IN_SPEECH_CALL;
3467                         break;
3468
3469                 default:
3470                         tr->terminal_rsp_data.send_dtmf.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
3471                         tr->terminal_rsp_data.send_dtmf.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3472                         break;
3473         }
3474
3475         result = TRUE;
3476         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
3477         if(rv != TCORE_RETURN_SUCCESS){
3478                 dbg("fail to send terminal response");
3479                 result = FALSE;
3480         }
3481
3482         g_free(tr);
3483         return result;
3484 }
3485
3486 static gboolean sat_manager_handle_launch_browser_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, GVariant *exec_result)
3487 {
3488         TReturn rv = TCORE_RETURN_FAILURE;
3489         gboolean result = FALSE;
3490
3491         gint resp, browser_problem;
3492         struct treq_sat_terminal_rsp_data *tr;
3493         struct sat_manager_queue_data q_data;
3494
3495         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
3496
3497         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
3498                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
3499                 return result;
3500         }
3501
3502         if(!exec_result){
3503                 dbg("[SAT] get channel status data is null");
3504                 return result;
3505         }
3506
3507         if (!plg){
3508                 dbg("there is no valid plugin at this point");
3509                 return result;
3510         }
3511
3512         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
3513         g_variant_get(exec_result, "(ii)",&resp,&browser_problem);
3514
3515         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
3516         tr->cmd_number = q_data.cmd_data.launch_browser.command_detail.cmd_num;
3517         tr->cmd_type = q_data.cmd_data.launch_browser.command_detail.cmd_type;
3518         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));
3519
3520         tr->terminal_rsp_data.launch_browser.device_id.src = q_data.cmd_data.launch_browser.device_id.dest;
3521         tr->terminal_rsp_data.launch_browser.device_id.dest = q_data.cmd_data.launch_browser.device_id.src;
3522
3523         tr->terminal_rsp_data.launch_browser.result_type = resp;
3524         switch (resp) {
3525                 case RESULT_SUCCESS:
3526                         if (q_data.cmd_data.launch_browser.user_confirm_icon_id.icon_info.ics == IMAGE_CODING_SCHEME_COLOUR)
3527                                 tr->terminal_rsp_data.launch_browser.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
3528
3529                         tr->terminal_rsp_data.launch_browser.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3530                         tr->terminal_rsp_data.launch_browser.browser_problem_type = BROWSER_PROBLEM_NO_SPECIFIC_CAUSE;
3531                         break;
3532                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
3533                         tr->terminal_rsp_data.launch_browser.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3534                         tr->terminal_rsp_data.launch_browser.browser_problem_type = BROWSER_PROBLEM_NO_SPECIFIC_CAUSE;
3535                         break;
3536
3537                 case RESULT_LAUNCH_BROWSER_GENERIC_ERROR_CODE:
3538                         tr->terminal_rsp_data.launch_browser.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3539                         tr->terminal_rsp_data.launch_browser.browser_problem_type = browser_problem;
3540                         break;
3541                 default:
3542                         tr->terminal_rsp_data.launch_browser.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
3543                         tr->terminal_rsp_data.launch_browser.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3544                         tr->terminal_rsp_data.launch_browser.browser_problem_type = BROWSER_PROBLEM_NO_SPECIFIC_CAUSE;
3545                         break;
3546         }
3547
3548         result = TRUE;
3549         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
3550         if(rv != TCORE_RETURN_SUCCESS){
3551                 dbg("fail to send terminal response");
3552                 result = FALSE;
3553         }
3554
3555         g_free(tr);
3556         return result;
3557 }
3558
3559 gboolean sat_manager_handle_app_exec_result(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gint command_type, GVariant *exec_result)
3560 {
3561         gboolean result = FALSE;
3562         GVariant *resp = NULL;
3563         dbg("[SAT] app exec result command id(%d) command type(%d)", command_id, command_type);
3564
3565         dbg("exec_result type_format(%s)", g_variant_get_type_string(exec_result));
3566         g_variant_get(exec_result, "v", &resp);
3567
3568         switch (command_type) {
3569                 case SAT_PROATV_CMD_SETUP_MENU:
3570                         result = _sat_manager_handle_setup_menu_result(ctx, plg, command_id, resp);
3571                         break;
3572
3573                 case SAT_PROATV_CMD_DISPLAY_TEXT:
3574                         result = _sat_manager_handle_display_text_result(ctx, plg, command_id, resp);
3575                         break;
3576
3577                 case SAT_PROATV_CMD_PLAY_TONE:
3578                         result = _sat_manager_handle_play_tone_result(ctx, plg, command_id, resp);
3579                         break;
3580
3581                 case SAT_PROATV_CMD_SEND_SMS:
3582                         result = _sat_manager_handle_send_sms_result(ctx, plg, command_id, resp);
3583                         break;
3584
3585                 case SAT_PROATV_CMD_SEND_SS:
3586                         result = _sat_manager_handle_send_ss_result(ctx, plg, command_id, resp);
3587                         break;
3588
3589                 case SAT_PROATV_CMD_SEND_USSD:
3590                         result = _sat_manager_handle_send_ussd_result(ctx, plg, command_id, resp);
3591                         break;
3592
3593                 case SAT_PROATV_CMD_SETUP_CALL:
3594                         result = _sat_manager_handle_setup_call_result(ctx, plg, command_id, resp);
3595                         break;
3596
3597                 case SAT_PROATV_CMD_SETUP_IDLE_MODE_TEXT:
3598                         result = _sat_manager_handle_setup_idle_mode_text_result(ctx, plg, command_id, resp);
3599                         break;
3600
3601                 case SAT_PROATV_CMD_OPEN_CHANNEL:
3602                         result = sat_manager_handle_open_channel_result(ctx, plg, command_id, resp);
3603                         break;
3604
3605                 case SAT_PROATV_CMD_CLOSE_CHANNEL:
3606                         result = sat_manager_handle_close_channel_result(ctx, plg, command_id, resp);
3607                         break;
3608
3609                 case SAT_PROATV_CMD_RECEIVE_DATA:
3610                         result = sat_manager_handle_receive_data_result(ctx, plg, command_id, resp);
3611                         break;
3612
3613                 case SAT_PROATV_CMD_SEND_DATA:
3614                         result = sat_manager_handle_send_data_result(ctx, plg, command_id, resp);
3615                         break;
3616
3617                 case SAT_PROATV_CMD_GET_CHANNEL_STATUS:
3618                         result = sat_manager_handle_get_channel_status_result(ctx, plg, command_id, resp);
3619                         break;
3620
3621                 case SAT_PROATV_CMD_SEND_DTMF:
3622                         result = sat_manager_handle_send_dtmf_result(ctx, plg, command_id, resp);
3623                         break;
3624
3625                 case SAT_PROATV_CMD_LAUNCH_BROWSER:
3626                         result = sat_manager_handle_launch_browser_result(ctx, plg, command_id, resp);
3627                         break;
3628
3629                 default:
3630                         dbg("[SAT] invalid command type(%d)", command_type);
3631                         break;
3632         }
3633
3634         sat_ui_support_terminate_sat_ui();
3635
3636         return result;
3637 }
3638
3639 static gboolean _sat_manager_handle_menu_select_confirm(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gint confirm_type, GVariant *addtional_data)
3640 {
3641         TReturn rv = TCORE_RETURN_FAILURE;
3642         gboolean result = FALSE;
3643
3644         gint item_id=0;
3645         struct treq_sat_terminal_rsp_data *tr;
3646         struct sat_manager_queue_data q_data;
3647
3648         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
3649
3650         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
3651                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
3652                 return result;
3653         }
3654
3655         if (!plg){
3656                 dbg("there is no valid plugin at this point");
3657                 return result;
3658         }
3659
3660         if(addtional_data){
3661                 int index = 0;
3662                 guchar data;
3663                 GVariantIter *iter = NULL;
3664                 GVariant *inner_gv = NULL;
3665
3666                 inner_gv = g_variant_get_variant(addtional_data);
3667                 dbg("additional data exist type_format(%s)", g_variant_get_type_string(inner_gv));
3668
3669                 g_variant_get(inner_gv, "ay", &iter);
3670                 while( g_variant_iter_loop (iter, "y", &data)){
3671                         dbg("index(%d) data(%d)", index, data);
3672                         item_id = data;
3673                         index++;
3674                 }
3675                 g_variant_iter_free(iter);
3676                 g_variant_unref(inner_gv);
3677         }
3678
3679         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
3680         tr->cmd_number = q_data.cmd_data.selectItemInd.command_detail.cmd_num;
3681         tr->cmd_type = q_data.cmd_data.selectItemInd.command_detail.cmd_type;
3682         memcpy((void*)&tr->terminal_rsp_data.select_item.command_detail, &q_data.cmd_data.selectItemInd.command_detail, sizeof(struct tel_sat_cmd_detail_info));
3683         tr->terminal_rsp_data.select_item.device_id.src = DEVICE_ID_ME;
3684         tr->terminal_rsp_data.select_item.device_id.dest = DEVICE_ID_SIM;
3685
3686         switch (confirm_type) {
3687                 case USER_CONFIRM_YES:
3688                         tr->terminal_rsp_data.select_item.item_identifier.item_identifier = item_id;
3689                         tr->terminal_rsp_data.select_item.other_info = FALSE;
3690                         tr->terminal_rsp_data.select_item.result_type = RESULT_SUCCESS;
3691                         tr->terminal_rsp_data.select_item.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3692
3693                         if (q_data.cmd_data.selectItemInd.icon_id.icon_info.ics == IMAGE_CODING_SCHEME_COLOUR)
3694                                 tr->terminal_rsp_data.select_item.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
3695
3696                         break;
3697
3698                 case USER_CONFIRM_HELP_INFO:
3699                         tr->terminal_rsp_data.select_item.item_identifier.item_identifier = item_id;
3700                         tr->terminal_rsp_data.select_item.other_info = FALSE;
3701                         tr->terminal_rsp_data.select_item.result_type = RESULT_HELP_INFO_REQUIRED_BY_USER;
3702                         tr->terminal_rsp_data.select_item.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3703                         //TODO ctx->help_requested = TRUE;
3704                         break;
3705
3706                 case USER_CONFIRM_END:
3707                         tr->terminal_rsp_data.select_item.result_type = RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER;
3708                         break;
3709
3710                 case USER_CONFIRM_NO_OR_CANCEL:
3711                         tr->terminal_rsp_data.select_item.result_type = RESULT_BACKWARD_MOVE_BY_USER;
3712                         break;
3713
3714                 case USER_CONFIRM_TIMEOUT:
3715                         tr->terminal_rsp_data.select_item.result_type = RESULT_NO_RESPONSE_FROM_USER;
3716                         break;
3717
3718                 default:
3719                         dbg("not handled value[%d] here", confirm_type);
3720                         break;
3721         }
3722
3723         result = TRUE;
3724         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
3725         if(rv != TCORE_RETURN_SUCCESS){
3726                 dbg("fail to send terminal response");
3727                 result = FALSE;
3728         }
3729
3730         g_free(tr);
3731
3732         return result;
3733 }
3734
3735 static gboolean _sat_manager_handle_display_text_confirm(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gint confirm_type, GVariant *addtional_data)
3736 {
3737         TReturn rv = TCORE_RETURN_FAILURE;
3738         gboolean result = FALSE;
3739
3740         struct treq_sat_terminal_rsp_data *tr;
3741         struct sat_manager_queue_data q_data;
3742
3743         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
3744
3745         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
3746                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
3747                 return result;
3748         }
3749
3750         if (!plg){
3751                 dbg("there is no valid plugin at this point");
3752                 return result;
3753         }
3754
3755         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
3756         tr->cmd_number = q_data.cmd_data.displayTextInd.command_detail.cmd_num;
3757         tr->cmd_type = q_data.cmd_data.displayTextInd.command_detail.cmd_type;
3758         memcpy((void*)&tr->terminal_rsp_data.display_text.command_detail, &q_data.cmd_data.displayTextInd.command_detail, sizeof(struct tel_sat_cmd_detail_info));
3759         tr->terminal_rsp_data.display_text.device_id.src = DEVICE_ID_ME;
3760         tr->terminal_rsp_data.display_text.device_id.dest = DEVICE_ID_SIM;
3761
3762         switch (confirm_type){
3763                 case USER_CONFIRM_YES: {
3764                         tr->terminal_rsp_data.display_text.result_type = RESULT_SUCCESS;
3765                         tr->terminal_rsp_data.display_text.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
3766
3767                         if (q_data.cmd_data.displayTextInd.icon_id.icon_info.ics == IMAGE_CODING_SCHEME_COLOUR)
3768                                 tr->terminal_rsp_data.display_text.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
3769                 } break;
3770
3771                 case USER_CONFIRM_NO_OR_CANCEL:
3772                         tr->terminal_rsp_data.display_text.result_type = RESULT_BACKWARD_MOVE_BY_USER;
3773                         break;
3774
3775                 case USER_CONFIRM_TIMEOUT:
3776                         tr->terminal_rsp_data.display_text.result_type = RESULT_SUCCESS;
3777
3778                         if (q_data.cmd_data.displayTextInd.command_detail.cmd_qualifier.display_text.text_clear_type == TEXT_WAIT_FOR_USER_TO_CLEAR_MSG )
3779                                 tr->terminal_rsp_data.display_text.result_type = RESULT_NO_RESPONSE_FROM_USER;
3780
3781                         break;
3782
3783                 case USER_CONFIRM_END:
3784                         tr->terminal_rsp_data.display_text.result_type = RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER;
3785                         break;
3786
3787                 case USER_CONFIRM_HELP_INFO:
3788                 default:
3789                         dbg("not handled value[%d] here", confirm_type);
3790                         break;
3791         }
3792
3793         result = TRUE;
3794         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
3795         if(rv != TCORE_RETURN_SUCCESS){
3796                 dbg("fail to send terminal response");
3797                 result = FALSE;
3798         }
3799
3800         g_free(tr);
3801
3802         return result;
3803 }
3804
3805 static gboolean _sat_manager_handle_get_inkey_confirm(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gint confirm_type, GVariant *addtional_data)
3806 {
3807         TReturn rv = TCORE_RETURN_FAILURE;
3808         gboolean result = FALSE;
3809
3810         gint inkey_data_len = 0;
3811         gchar inkey_data[SAT_TEXT_STRING_LEN_MAX];
3812         struct treq_sat_terminal_rsp_data *tr;
3813         struct sat_manager_queue_data q_data;
3814
3815         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
3816         memset(inkey_data, 0, SAT_TEXT_STRING_LEN_MAX);
3817
3818         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
3819                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
3820                 return result;
3821         }
3822
3823         if (!plg){
3824                 dbg("there is no valid plugin at this point");
3825                 return result;
3826         }
3827
3828         if(addtional_data){
3829                 int index = 0;
3830                 guchar data;
3831                 GVariantIter *iter = NULL;
3832                 GVariant *inner_gv = NULL;
3833
3834                 inner_gv = g_variant_get_variant(addtional_data);
3835                 dbg("additional data exist type_format(%s)", g_variant_get_type_string(inner_gv));
3836
3837                 g_variant_get(inner_gv, "ay", &iter);
3838                 while( g_variant_iter_loop (iter, "y", &data)){
3839                         dbg("index(%d) data(%d)", index, data);
3840                         inkey_data[index] = data;
3841                         index++;
3842                 }
3843                 g_variant_iter_free(iter);
3844                 g_variant_unref(inner_gv);
3845                 inkey_data_len = index;
3846         }
3847
3848         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
3849         tr->cmd_number = q_data.cmd_data.getInkeyInd.command_detail.cmd_num;
3850         tr->cmd_type = q_data.cmd_data.getInkeyInd.command_detail.cmd_type;
3851         memcpy((void*)&tr->terminal_rsp_data.get_inkey.command_detail, &q_data.cmd_data.getInkeyInd.command_detail, sizeof(struct tel_sat_cmd_detail_info));
3852         tr->terminal_rsp_data.get_inkey.device_id.src = DEVICE_ID_ME;
3853         tr->terminal_rsp_data.get_inkey.device_id.dest = DEVICE_ID_SIM;
3854
3855         switch (confirm_type){
3856                 case USER_CONFIRM_YES:
3857                         tr->terminal_rsp_data.get_inkey.result_type = RESULT_SUCCESS;
3858
3859                         if (q_data.cmd_data.getInkeyInd.icon_id.icon_info.ics == IMAGE_CODING_SCHEME_COLOUR)
3860                                 tr->terminal_rsp_data.get_inkey.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
3861
3862                         if (q_data.cmd_data.getInkeyInd.command_detail.cmd_qualifier.get_inkey.inkey_type == INKEY_TYPE_YES_NO_REQUESTED) {
3863                                 tr->terminal_rsp_data.get_inkey.text.dcs.m_class = MSG_CLASS_RESERVED;
3864                                 tr->terminal_rsp_data.get_inkey.text.dcs.a_format = ALPHABET_FORMAT_8BIT_DATA;
3865                                 tr->terminal_rsp_data.get_inkey.text.string_length = 1;
3866                                 tr->terminal_rsp_data.get_inkey.text.string[0] = 0x01;
3867                         }
3868                         else if(inkey_data_len > 0)
3869                         {
3870                                 tr->terminal_rsp_data.get_inkey.text.string_length = inkey_data_len;
3871
3872                                 if (!q_data.cmd_data.getInkeyInd.command_detail.cmd_qualifier.get_inkey.alphabet_set){
3873                                         tr->terminal_rsp_data.get_inkey.text.is_digit_only = TRUE;
3874                                         tr->terminal_rsp_data.get_inkey.text.dcs.a_format = ALPHABET_FORMAT_8BIT_DATA;
3875                                         tr->terminal_rsp_data.get_inkey.text.dcs.m_class = MSG_CLASS_RESERVED;
3876
3877                                         memcpy((void*)tr->terminal_rsp_data.get_inkey.text.string, inkey_data, inkey_data_len);
3878                                 }
3879                                 else
3880                                 {
3881                                         tr->terminal_rsp_data.get_inkey.text.dcs.m_class = MSG_CLASS_RESERVED;
3882
3883                                         if(q_data.cmd_data.getInkeyInd.command_detail.cmd_qualifier.get_inkey.alphabet_type == INPUT_ALPHABET_TYPE_SMS_DEFAULT )
3884                                         {
3885                                                 int tmp_len;
3886                                                 char tmp_str[SAT_TEXT_STRING_LEN_MAX + 1], *packed_data;
3887
3888                                                 dbg("sat gsm7 encoding");
3889                                                 tcore_util_convert_utf8_to_gsm((unsigned char*) tmp_str, &tmp_len, (unsigned char*)inkey_data, inkey_data_len);
3890                                                 packed_data = (char*) tcore_util_pack_gsm7bit((const unsigned char *)tmp_str, tmp_len);
3891
3892                                                 if(packed_data){
3893                                                         tr->terminal_rsp_data.get_inkey.text.dcs.a_format = ALPHABET_FORMAT_8BIT_DATA;
3894                                                         tr->terminal_rsp_data.get_inkey.text.string_length = strlen(packed_data);
3895                                                         memcpy((void*) tr->terminal_rsp_data.get_inkey.text.string, packed_data, strlen(packed_data));
3896
3897                                                         g_free(packed_data);
3898                                                 }
3899                                         }
3900                                         else if(q_data.cmd_data.getInkeyInd.command_detail.cmd_qualifier.get_inkey.alphabet_type == INPUT_ALPHABET_TYPE_UCS2 )
3901                                         {
3902                                                 dbg("UCS2 DATA");
3903
3904                                                 tr->terminal_rsp_data.get_inkey.text.dcs.a_format = ALPHABET_FORMAT_UCS2;
3905                                                 tcore_util_convert_utf8_to_ucs2((unsigned char*)tr->terminal_rsp_data.get_inkey.text.string,
3906                                                                 &tr->terminal_rsp_data.get_inkey.text.string_length, (unsigned char*)inkey_data, inkey_data_len);
3907                                         }
3908                                         else
3909                                         {
3910                                                 tr->terminal_rsp_data.get_inkey.text.dcs.a_format = ALPHABET_FORMAT_RESERVED;
3911                                                 dbg("[SAT] invalid DCS[%d]",tr->terminal_rsp_data.get_inkey.text.dcs.a_format);
3912                                         }
3913                                 }
3914                         }
3915                         break;
3916
3917                 case USER_CONFIRM_HELP_INFO:
3918                         tr->terminal_rsp_data.get_inkey.result_type = RESULT_HELP_INFO_REQUIRED_BY_USER;
3919                         //TODO ctx->help_requested = TRUE;
3920                         break;
3921
3922                 case USER_CONFIRM_NO_OR_CANCEL:
3923                         tr->terminal_rsp_data.get_inkey.result_type = RESULT_BACKWARD_MOVE_BY_USER;
3924
3925                         if (q_data.cmd_data.getInkeyInd.command_detail.cmd_qualifier.get_inkey.inkey_type == INKEY_TYPE_YES_NO_REQUESTED) {
3926                                 tr->terminal_rsp_data.get_inkey.result_type = RESULT_SUCCESS;
3927                                 tr->terminal_rsp_data.get_inkey.text.dcs.m_class = MSG_CLASS_RESERVED;
3928                                 tr->terminal_rsp_data.get_inkey.text.dcs.a_format = ALPHABET_FORMAT_8BIT_DATA;
3929                                 tr->terminal_rsp_data.get_inkey.text.string_length = 1;
3930                                 tr->terminal_rsp_data.get_inkey.text.string[0] = 0x00;
3931                         }
3932                         break;
3933
3934                 case USER_CONFIRM_TIMEOUT:
3935                         tr->terminal_rsp_data.get_inkey.result_type = RESULT_NO_RESPONSE_FROM_USER;
3936                         break;
3937
3938                 case USER_CONFIRM_END:
3939                         tr->terminal_rsp_data.get_inkey.result_type = RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER;
3940                         break;
3941
3942                 default:
3943                         dbg("not handled value[%d] here", confirm_type);
3944                         break;
3945         }
3946
3947         result = TRUE;
3948         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
3949         if(rv != TCORE_RETURN_SUCCESS){
3950                 dbg("fail to send terminal response");
3951                 result = FALSE;
3952         }
3953
3954         g_free(tr);
3955
3956         return result;
3957 }
3958
3959 static gboolean _sat_manager_handle_get_input_confirm(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gint confirm_type, GVariant *addtional_data)
3960 {
3961         TReturn rv = TCORE_RETURN_FAILURE;
3962         gboolean result = FALSE;
3963
3964         gint input_data_len = 0;
3965         gchar input_data[SAT_TEXT_STRING_LEN_MAX];
3966         struct treq_sat_terminal_rsp_data *tr;
3967         struct sat_manager_queue_data q_data;
3968
3969         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
3970         memset(input_data, 0, SAT_TEXT_STRING_LEN_MAX);
3971
3972         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
3973                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
3974                 return result;
3975         }
3976
3977         if (!plg){
3978                 dbg("there is no valid plugin at this point");
3979                 return result;
3980         }
3981
3982         if(addtional_data){
3983                 int index = 0;
3984                 guchar data;
3985                 GVariantIter *iter = NULL;
3986                 GVariant *inner_gv = NULL;
3987
3988                 inner_gv = g_variant_get_variant(addtional_data);
3989                 dbg("additional data exist type_format(%s)", g_variant_get_type_string(inner_gv));
3990
3991                 g_variant_get(inner_gv, "ay", &iter);
3992                 while( g_variant_iter_loop (iter, "y", &data)){
3993                         dbg("index(%d) data(%d)", index, data);
3994                         input_data[index] = data;
3995                         index++;
3996                 }
3997                 g_variant_iter_free(iter);
3998                 g_variant_unref(inner_gv);
3999                 input_data_len = index;
4000         }
4001
4002         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
4003         tr->cmd_number = q_data.cmd_data.getInputInd.command_detail.cmd_num;
4004         tr->cmd_type = q_data.cmd_data.getInputInd.command_detail.cmd_type;
4005         memcpy((void*)&tr->terminal_rsp_data.get_input.command_detail, &q_data.cmd_data.getInputInd.command_detail, sizeof(struct tel_sat_cmd_detail_info));
4006         tr->terminal_rsp_data.get_input.device_id.src = DEVICE_ID_ME;
4007         tr->terminal_rsp_data.get_input.device_id.dest = DEVICE_ID_SIM;
4008
4009         switch (confirm_type){
4010                 case USER_CONFIRM_YES:
4011                         tr->terminal_rsp_data.get_input.result_type = RESULT_SUCCESS;
4012                         tr->terminal_rsp_data.get_input.text.dcs.m_class = MSG_CLASS_RESERVED;
4013
4014                         if(!q_data.cmd_data.getInputInd.command_detail.cmd_qualifier.get_input.alphabet_set){
4015                                 tr->terminal_rsp_data.get_input.text.is_digit_only = TRUE;
4016                         }
4017
4018                         if (q_data.cmd_data.getInputInd.icon_id.icon_info.ics == IMAGE_CODING_SCHEME_COLOUR)
4019                                 tr->terminal_rsp_data.get_input.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
4020
4021                         if(!q_data.cmd_data.getInputInd.command_detail.cmd_qualifier.get_input.user_input_unpacked_format){
4022                                 dbg("[SAT] packing to SMS7 default");
4023
4024                                 tr->terminal_rsp_data.get_input.text.string_length = 0;
4025                                 tr->terminal_rsp_data.get_input.text.dcs.a_format = ALPHABET_FORMAT_SMS_DEFAULT;
4026
4027                                 if (input_data_len > 0){
4028                                         int tmp_len;
4029                                         char tmp_str[SAT_TEXT_STRING_LEN_MAX + 1], *packed_data;
4030
4031                                         dbg("sat gsm7 encoding");
4032                                         tcore_util_convert_utf8_to_gsm((unsigned char*)tmp_str, &tmp_len, (unsigned char*)input_data, input_data_len);
4033                                         packed_data = (char*) tcore_util_pack_gsm7bit((const unsigned char *)tmp_str, tmp_len);
4034
4035                                         if(packed_data){
4036                                                 memcpy((void*)tr->terminal_rsp_data.get_input.text.string, packed_data, strlen(packed_data));
4037                                                 tr->terminal_rsp_data.get_input.text.string_length = strlen(packed_data);
4038
4039                                                 g_free(packed_data);
4040                                         }
4041                                 }
4042
4043                         }
4044                         else
4045                         {
4046                                 dbg("[SAT] packing not required");
4047
4048                                 if(q_data.cmd_data.getInkeyInd.command_detail.cmd_qualifier.get_input.alphabet_type == INPUT_ALPHABET_TYPE_SMS_DEFAULT){
4049
4050                                         tr->terminal_rsp_data.get_input.text.dcs.a_format = ALPHABET_FORMAT_8BIT_DATA;
4051                                         tcore_util_convert_utf8_to_gsm((unsigned char*)tr->terminal_rsp_data.get_input.text.string,
4052                                                         &tr->terminal_rsp_data.get_input.text.string_length, (unsigned char*)input_data, input_data_len);
4053
4054                                 }
4055                                 else if(q_data.cmd_data.getInkeyInd.command_detail.cmd_qualifier.get_input.alphabet_type == INPUT_ALPHABET_TYPE_UCS2 ){
4056
4057                                         tr->terminal_rsp_data.get_input.text.dcs.a_format = ALPHABET_FORMAT_UCS2;
4058                                         tcore_util_convert_utf8_to_ucs2((unsigned char*)tr->terminal_rsp_data.get_input.text.string,
4059                                                         &tr->terminal_rsp_data.get_input.text.string_length, (unsigned char*)input_data, input_data_len);
4060
4061                                 }
4062                                 else{
4063                                         tr->terminal_rsp_data.get_input.text.dcs.a_format = ALPHABET_FORMAT_RESERVED;
4064                                         dbg("[SAT] invalid DCS[%d]",tr->terminal_rsp_data.get_input.text.dcs.a_format);
4065                                 }
4066                         } break;
4067
4068                 case USER_CONFIRM_HELP_INFO:
4069                         tr->terminal_rsp_data.get_input.result_type = RESULT_HELP_INFO_REQUIRED_BY_USER;
4070                         //TODO ctx->help_requested = TRUE;
4071                         break;
4072
4073                 case USER_CONFIRM_NO_OR_CANCEL:
4074                         tr->terminal_rsp_data.get_input.result_type = RESULT_BACKWARD_MOVE_BY_USER;
4075                         break;
4076
4077                 case USER_CONFIRM_TIMEOUT:
4078                         tr->terminal_rsp_data.get_input.result_type = RESULT_NO_RESPONSE_FROM_USER;
4079                         break;
4080
4081                 case USER_CONFIRM_END:
4082                         tr->terminal_rsp_data.get_input.result_type = RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER;
4083                         break;
4084                 default:
4085                         break;
4086         }
4087
4088         result = TRUE;
4089         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
4090         if(rv != TCORE_RETURN_SUCCESS){
4091                 dbg("fail to send terminal response");
4092                 result = FALSE;
4093         }
4094
4095         g_free(tr);
4096
4097         return result;
4098 }
4099
4100 static gboolean _sat_manager_handle_setup_call_confirm(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gint confirm_type, GVariant *addtional_data)
4101 {
4102         TReturn rv = TCORE_RETURN_FAILURE;
4103         gboolean result = FALSE;
4104
4105         gint input_data_len = 0;
4106         gchar input_data[SAT_TEXT_STRING_LEN_MAX];
4107         struct treq_sat_terminal_rsp_data *tr;
4108         struct sat_manager_queue_data q_data;
4109
4110         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
4111         memset(input_data, 0, SAT_TEXT_STRING_LEN_MAX);
4112
4113         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
4114                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
4115                 return result;
4116         }
4117
4118         if (!plg){
4119                 dbg("there is no valid plugin at this point");
4120                 return result;
4121         }
4122
4123         if(addtional_data){
4124                 int index = 0;
4125                 guchar data;
4126                 GVariantIter *iter = NULL;
4127                 GVariant *inner_gv = NULL;
4128
4129                 inner_gv = g_variant_get_variant(addtional_data);
4130                 dbg("additional data exist type_format(%s)", g_variant_get_type_string(inner_gv));
4131
4132                 g_variant_get(inner_gv, "ay", &iter);
4133                 while( g_variant_iter_loop (iter, "y", &data)){
4134                         dbg("index(%d) data(%d)", index, data);
4135                         input_data[index] = data;
4136                         index++;
4137                 }
4138                 g_variant_iter_free(iter);
4139                 g_variant_unref(inner_gv);
4140                 input_data_len = index;
4141         }
4142
4143         tr = g_new0(struct treq_sat_terminal_rsp_data, 1);
4144         tr->cmd_number = q_data.cmd_data.setup_call.command_detail.cmd_num;
4145         tr->cmd_type = q_data.cmd_data.setup_call.command_detail.cmd_type;
4146         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));
4147         tr->terminal_rsp_data.setup_call.device_id.src = DEVICE_ID_ME;
4148         tr->terminal_rsp_data.setup_call.device_id.dest = q_data.cmd_data.setup_call.device_id.src;
4149
4150         switch(confirm_type){
4151                 case USER_CONFIRM_YES:{
4152                         char *path;
4153                         TelephonySAT *sat;
4154                         TelephonyObjectSkeleton *object;
4155
4156                         gchar *plg_name = NULL;
4157                         GVariant *setup_call = NULL;
4158
4159                         gint command_id, call_type, confirmed_text_len, text_len, duration;
4160                         gchar *confirmed_text, *text, *call_number;
4161                         GVariant *icon_id;
4162
4163                         plg_name = (gchar *)tcore_server_get_cp_name_by_plugin(plg);
4164                         if (plg_name) {
4165                                 path = g_strdup_printf("%s/%s", MY_DBUS_PATH, plg_name);
4166                         }
4167                         else {
4168                                 path = g_strdup_printf("%s", MY_DBUS_PATH);
4169                         }
4170                         dbg("path = [%s]", path);
4171
4172                         object = g_hash_table_lookup(ctx->objects, path);
4173                         sat = telephony_object_peek_sat(TELEPHONY_OBJECT(object));
4174
4175                         setup_call = sat_manager_setup_call_noti(ctx, plg_name, &q_data.cmd_data.setup_call);
4176
4177                         dbg("setup call type_format(%s)", g_variant_get_type_string(setup_call));
4178                         g_variant_get(setup_call, "(isisi@visi)", &command_id, &confirmed_text, &confirmed_text_len, &text, &text_len, &icon_id, &call_type, &call_number, &duration);
4179
4180                         telephony_sat_emit_setup_call(sat, command_id, confirmed_text, confirmed_text_len, text, text_len, call_type,
4181                                         call_number, duration);
4182
4183                         sat_ui_support_launch_call_application(q_data.cmd_data.setup_call.command_detail.cmd_type, setup_call);
4184                         g_free(tr);
4185                         return TRUE;
4186                 }break;
4187
4188                 case USER_CONFIRM_NO_OR_CANCEL:{
4189                         tr->terminal_rsp_data.setup_call.result_type = RESULT_USER_DID_NOT_ACCEPT_CALL_SETUP_REQ;
4190                         tr->terminal_rsp_data.setup_call.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
4191                         tr->terminal_rsp_data.setup_call.cc_problem_type = CC_PROBLEM_NO_SPECIFIC_CAUSE;
4192                 }break;
4193
4194                 case USER_CONFIRM_END:{
4195                         tr->terminal_rsp_data.setup_call.result_type = RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER;
4196                 }break;
4197
4198                 case USER_CONFIRM_HELP_INFO:
4199                 default:
4200                         tr->terminal_rsp_data.setup_call.result_type = RESULT_NO_RESPONSE_FROM_USER;
4201                 break;
4202         }
4203
4204         result = TRUE;
4205         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
4206         if(rv != TCORE_RETURN_SUCCESS){
4207                 dbg("fail to send terminal response");
4208                 result = FALSE;
4209         }
4210         g_free(tr);
4211         return result;
4212 }
4213
4214 static gboolean _sat_manager_handle_send_dtmf_confirm(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gint confirm_type, GVariant *addtional_data)
4215 {
4216         TReturn rv = TCORE_RETURN_FAILURE;
4217         gboolean result = FALSE;
4218
4219         struct treq_sat_terminal_rsp_data *tr;
4220         struct sat_manager_queue_data q_data;
4221
4222         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
4223
4224         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
4225                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
4226                 return result;
4227         }
4228
4229         if (!plg){
4230                 dbg("there is no valid plugin at this point");
4231                 return result;
4232         }
4233
4234         tr = g_new0(struct treq_sat_terminal_rsp_data, 1);
4235         tr->cmd_number = q_data.cmd_data.send_dtmf.command_detail.cmd_num;
4236         tr->cmd_type = q_data.cmd_data.send_dtmf.command_detail.cmd_type;
4237         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));
4238         tr->terminal_rsp_data.send_dtmf.device_id.src = DEVICE_ID_ME;
4239         tr->terminal_rsp_data.send_dtmf.device_id.dest = q_data.cmd_data.send_dtmf.device_id.src;
4240
4241         dbg("confirm_type[%d]", confirm_type);
4242
4243         switch(confirm_type){
4244                 case USER_CONFIRM_NO_OR_CANCEL:
4245                 case USER_CONFIRM_END:
4246                         tr->terminal_rsp_data.send_dtmf.result_type = RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER;
4247                         tr->terminal_rsp_data.send_dtmf.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
4248                         break;
4249                 default:
4250                         tr->terminal_rsp_data.send_dtmf.result_type = RESULT_NO_RESPONSE_FROM_USER;
4251                         break;
4252         }
4253
4254         result = TRUE;
4255         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
4256         if(rv != TCORE_RETURN_SUCCESS){
4257                 dbg("fail to send terminal response");
4258                 result = FALSE;
4259         }
4260         g_free(tr);
4261
4262         return result;
4263 }
4264
4265 static gboolean _sat_manager_handle_launch_browser_confirm(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gint confirm_type, GVariant *addtional_data)
4266 {
4267         TReturn rv = TCORE_RETURN_FAILURE;
4268         gboolean result = FALSE;
4269
4270         struct treq_sat_terminal_rsp_data *tr;
4271         struct sat_manager_queue_data q_data;
4272
4273         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
4274
4275         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
4276                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
4277                 return result;
4278         }
4279
4280         if (!plg){
4281                 dbg("there is no valid plugin at this point");
4282                 return result;
4283         }
4284
4285         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
4286         tr->cmd_number = q_data.cmd_data.launch_browser.command_detail.cmd_num;
4287         tr->cmd_type = q_data.cmd_data.launch_browser.command_detail.cmd_type;
4288         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));
4289         tr->terminal_rsp_data.launch_browser.device_id.src = q_data.cmd_data.launch_browser.device_id.dest;
4290         tr->terminal_rsp_data.launch_browser.device_id.dest = q_data.cmd_data.launch_browser.device_id.src;
4291
4292         dbg("confirm_type[%d]", confirm_type);
4293
4294         switch(confirm_type){
4295                 case USER_CONFIRM_YES:{
4296                         char *path;
4297                         TelephonySAT *sat;
4298                         TelephonyObjectSkeleton *object;
4299
4300                         gchar *plg_name = NULL;
4301                         GVariant *launch_browser = NULL;
4302
4303                         gint command_id = 0;
4304                         gint browser_launch_type = 0, browser_id = 0;
4305                         gint url_len = 0, text_len = 0, gateway_proxy_len =0;
4306                         gchar *url = NULL;
4307                         gchar *text = NULL;
4308                         gchar *gateway_proxy = NULL;
4309                         GVariant *icon_id = NULL;
4310
4311                         plg_name = (gchar *)tcore_server_get_cp_name_by_plugin(plg);
4312                         if (plg_name) {
4313                                 path = g_strdup_printf("%s/%s", MY_DBUS_PATH, plg_name);
4314                         } else {
4315                                 path = g_strdup_printf("%s", MY_DBUS_PATH);
4316                         }
4317                         dbg("path = [%s]", path);
4318
4319                         object = g_hash_table_lookup(ctx->objects, path);
4320                         sat = telephony_object_peek_sat(TELEPHONY_OBJECT(object));
4321
4322                         launch_browser = sat_manager_launch_browser_noti(ctx, plg_name, &q_data.cmd_data.launch_browser);
4323
4324                         dbg("launch_browser type_format(%s)", g_variant_get_type_string(launch_browser));
4325                         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);
4326
4327                         telephony_sat_emit_launch_browser(sat, command_id, browser_launch_type, browser_id, url, url_len, gateway_proxy, gateway_proxy_len, text, text_len);
4328
4329                         sat_ui_support_launch_browser_application(q_data.cmd_data.launch_browser.command_detail.cmd_type, launch_browser);
4330
4331                         g_free(path);
4332                         g_free(tr);
4333
4334                         return TRUE;
4335                 }break;
4336
4337                 case USER_CONFIRM_NO_OR_CANCEL:
4338                 case USER_CONFIRM_END:
4339                         tr->terminal_rsp_data.launch_browser.result_type = RESULT_BACKWARD_MOVE_BY_USER;
4340                         tr->terminal_rsp_data.launch_browser.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
4341                         tr->terminal_rsp_data.launch_browser.browser_problem_type = BROWSER_PROBLEM_NO_SPECIFIC_CAUSE;
4342                         break;
4343
4344                 default:
4345                         tr->terminal_rsp_data.launch_browser.result_type = RESULT_NO_RESPONSE_FROM_USER;
4346                         break;
4347         }
4348
4349         result = TRUE;
4350         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
4351         if(rv != TCORE_RETURN_SUCCESS){
4352                 dbg("fail to send terminal response");
4353                 result = FALSE;
4354         }
4355         g_free(tr);
4356
4357         return result;
4358 }
4359
4360 static gboolean _sat_manager_handle_open_channel_confirm(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gint confirm_type, GVariant *addtional_data)
4361 {
4362         TReturn rv = TCORE_RETURN_FAILURE;
4363         gboolean result = FALSE;
4364
4365         struct treq_sat_terminal_rsp_data *tr;
4366         struct sat_manager_queue_data q_data;
4367
4368         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
4369
4370         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
4371                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
4372                 return result;
4373         }
4374
4375         if (!plg){
4376                 dbg("there is no valid plugin at this point");
4377                 return result;
4378         }
4379
4380         tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
4381         tr->cmd_number = q_data.cmd_data.open_channel.command_detail.cmd_num;
4382         tr->cmd_type = q_data.cmd_data.open_channel.command_detail.cmd_type;
4383         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));
4384         tr->terminal_rsp_data.open_channel.device_id.src = q_data.cmd_data.send_dtmf.device_id.dest;
4385         tr->terminal_rsp_data.open_channel.device_id.dest = q_data.cmd_data.send_dtmf.device_id.src;
4386
4387         dbg("confirm_type[%d]", confirm_type);
4388
4389         switch(confirm_type){
4390                 case USER_CONFIRM_YES:{
4391                         char *path;
4392                         TelephonyObjectSkeleton *object;
4393
4394                         gchar *plg_name = NULL;
4395
4396                         GVariant *open_channel = NULL;
4397
4398                         gint command_id, bearer_type, protocol_type, dest_addr_type;
4399                         gboolean immediate_link, auto_reconnection, bg_mode;
4400                         gint text_len, buffer_size, port_number;
4401                         gchar *text, *dest_address;
4402                         GVariant *icon_id;
4403                         GVariant *bearer_param;
4404                         GVariant *bearer_detail;
4405
4406                         //emit send_dtmf signal
4407                         plg_name = (gchar *)tcore_server_get_cp_name_by_plugin(plg);
4408                         if (plg_name) {
4409                                 path = g_strdup_printf("%s/%s", MY_DBUS_PATH, plg_name);
4410                         } else {
4411                                 path = g_strdup_printf("%s", MY_DBUS_PATH);
4412                         }
4413                         dbg("path = [%s]", path);
4414
4415                         object = g_hash_table_lookup(ctx->objects, path);
4416
4417                         open_channel = sat_manager_open_channel_noti(ctx, plg_name, &q_data.cmd_data.open_channel);
4418
4419                         dbg("open channel type_format(%s)", g_variant_get_type_string(open_channel));
4420                         g_variant_get(open_channel,"(isi@vbbbi@viiiis@v)", &command_id, &text, &text_len, &icon_id, &immediate_link, &auto_reconnection, &bg_mode,
4421                                         &bearer_type, &bearer_param, &buffer_size, &protocol_type, &port_number, &dest_addr_type, &dest_address, &bearer_detail);
4422
4423                         /*telephony_sat_emit_open_channel(sat, command_id, text, text_len, immediate_link, auto_reconnection, bg_mode,
4424                                         bearer_type, bearer_param, buffer_size, protocol_type, port_number, dest_addr_type, dest_address, bearer_detail);*/
4425
4426                         //BIP Manager
4427                         {
4428                                 gboolean b_sig = FALSE;
4429                                 GDBusConnection *conn = NULL;
4430                                 const gchar *g_path = NULL;
4431
4432                                 conn = g_dbus_object_manager_server_get_connection(ctx->manager);
4433                                 g_path = g_dbus_object_get_object_path(G_DBUS_OBJECT(object));
4434
4435                                 b_sig = sat_ui_support_exec_bip(conn, g_path, SAT_PROATV_CMD_OPEN_CHANNEL, open_channel);
4436                         }
4437
4438                         g_free(path);
4439                         g_free(tr);
4440
4441                         return TRUE;
4442                 }break;
4443
4444                 case USER_CONFIRM_NO_OR_CANCEL:
4445                 case USER_CONFIRM_END:
4446                         tr->terminal_rsp_data.open_channel.result_type = RESULT_USER_DID_NOT_ACCEPT_CALL_SETUP_REQ;
4447                         break;
4448                 default:
4449                         tr->terminal_rsp_data.open_channel.result_type = RESULT_NO_RESPONSE_FROM_USER;
4450                         break;
4451         }
4452
4453         memcpy((void*)&tr->terminal_rsp_data.open_channel.bearer_desc, &q_data.cmd_data.open_channel.bearer_desc, sizeof(struct tel_sat_bearer_description));
4454         memcpy((void*)&tr->terminal_rsp_data.open_channel.buffer_size, &q_data.cmd_data.open_channel.buffer_size, sizeof(struct tel_sat_buffer_size));
4455
4456         result = TRUE;
4457         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
4458         if(rv != TCORE_RETURN_SUCCESS){
4459                 dbg("fail to send terminal response");
4460                 result = FALSE;
4461         }
4462         g_free(tr);
4463
4464         return result;
4465 }
4466
4467 gboolean sat_manager_handle_user_confirm(struct custom_data *ctx, TcorePlugin *plg, GVariant *user_confirm_data)
4468 {
4469         gboolean rv = FALSE;
4470         gboolean result = FALSE;
4471         struct sat_manager_queue_data q_data;
4472
4473         gint command_id, command_type, confirm_type;
4474         GVariant *additional_data = NULL;
4475
4476         dbg("user_confirm_data type_format(%s)", g_variant_get_type_string(user_confirm_data));
4477         g_variant_get(user_confirm_data, "(iiv)", &command_id, &confirm_type, &additional_data);
4478
4479         dbg("[SAT] user confirm data command id(%d), confirm_type(%d)", command_id, confirm_type);
4480
4481         rv = sat_manager_queue_peek_data_by_id(ctx, &q_data, command_id);
4482         if(!rv){
4483                 dbg("[SAT] no commands in queue");
4484                 return result;
4485         }
4486
4487         command_type = (gint)q_data.cmd_type;
4488         dbg("[SAT] command type(%d)", command_type);
4489
4490         switch(command_type){
4491                 case SAT_PROATV_CMD_SELECT_ITEM:
4492                         result = _sat_manager_handle_menu_select_confirm(ctx, plg, command_id, confirm_type, additional_data);
4493                         break;
4494                 case SAT_PROATV_CMD_DISPLAY_TEXT:
4495                         result = _sat_manager_handle_display_text_confirm(ctx, plg, command_id, confirm_type, additional_data);
4496                         break;
4497                 case SAT_PROATV_CMD_GET_INKEY:
4498                         result = _sat_manager_handle_get_inkey_confirm(ctx, plg, command_id, confirm_type, additional_data);
4499                         break;
4500                 case SAT_PROATV_CMD_GET_INPUT:
4501                         result = _sat_manager_handle_get_input_confirm(ctx, plg, command_id, confirm_type, additional_data);
4502                         break;
4503                 case SAT_PROATV_CMD_SETUP_CALL:
4504                         result = _sat_manager_handle_setup_call_confirm(ctx, plg, command_id, confirm_type, additional_data);
4505                         break;
4506                 case SAT_PROATV_CMD_SEND_DTMF:
4507                         result = _sat_manager_handle_send_dtmf_confirm(ctx, plg, command_id, confirm_type, additional_data);
4508                         break;
4509                 case SAT_PROATV_CMD_LAUNCH_BROWSER:
4510                         result = _sat_manager_handle_launch_browser_confirm(ctx, plg, command_id, confirm_type, additional_data);
4511                         break;
4512                 case SAT_PROATV_CMD_OPEN_CHANNEL:
4513                         result = _sat_manager_handle_open_channel_confirm(ctx, plg, command_id, confirm_type, additional_data);
4514                         break;
4515                 default:
4516                         dbg("[SAT] cannot handle user confirm command(0x%x)", command_type);
4517                         break;
4518         }
4519
4520         return result;
4521 }
4522
4523 static gboolean _sat_manager_handle_play_tone_ui_display_status(struct custom_data *ctx, TcorePlugin *plg,struct sat_manager_queue_data *q_data, gboolean display_status)
4524 {
4525         char *path;
4526         TelephonySAT *sat;
4527         TelephonyObjectSkeleton *object;
4528
4529         gchar *plg_name = NULL;
4530         GVariant *play_tone = NULL;
4531
4532
4533         gint command_id, tone_type, duration;
4534         gint text_len;
4535         gchar* text;
4536         GVariant *icon_id;
4537
4538         if(!display_status){
4539                 struct treq_sat_terminal_rsp_data *tr = NULL;
4540                 dbg("[SAT] fail to show ui display for play tone");
4541
4542                 tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
4543
4544                 tr->cmd_number = q_data->cmd_data.play_tone.command_detail.cmd_num;
4545                 tr->cmd_type = q_data->cmd_data.play_tone.command_detail.cmd_type;
4546                 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));
4547
4548                 tr->terminal_rsp_data.play_tone.device_id.src = DEVICE_ID_ME;
4549                 tr->terminal_rsp_data.play_tone.device_id.dest = q_data->cmd_data.play_tone.device_id.src;
4550                 tr->terminal_rsp_data.play_tone.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
4551
4552                 sat_manager_send_terminal_response(ctx->comm, plg, tr);
4553                 g_free(tr);
4554
4555                 return TRUE;
4556         }
4557
4558         //emit play tone signal
4559         plg_name = (gchar *)tcore_server_get_cp_name_by_plugin(plg);
4560         if (plg_name) {
4561                 path = g_strdup_printf("%s/%s", MY_DBUS_PATH, plg_name);
4562         }
4563         else {
4564                 path = g_strdup_printf("%s", MY_DBUS_PATH);
4565         }
4566         dbg("path = [%s]", path);
4567
4568         object = g_hash_table_lookup(ctx->objects, path);
4569         sat = telephony_object_peek_sat(TELEPHONY_OBJECT(object));
4570
4571         play_tone = sat_manager_play_tone_noti(ctx, plg_name, &q_data->cmd_data.play_tone);
4572
4573         dbg("play tone type_format(%s)", g_variant_get_type_string(play_tone));
4574         g_variant_get(play_tone, "(isi@vii)", &command_id, &text, &text_len, &icon_id, &tone_type, &duration);
4575
4576         telephony_sat_emit_play_tone(sat, command_id, text, text_len, tone_type, duration);
4577         g_free(path);
4578
4579         return TRUE;
4580 }
4581
4582 static gboolean _sat_manager_handle_send_sms_ui_display_status(struct custom_data *ctx, TcorePlugin *plg,struct sat_manager_queue_data *q_data, gboolean display_status)
4583 {
4584         char *path;
4585         TelephonySAT *sat;
4586         TelephonyObjectSkeleton *object;
4587
4588         gchar *plg_name = NULL;
4589         GVariant *send_sms = NULL;
4590
4591
4592         gint command_id, ton, npi, tpdu_type;
4593         gboolean b_packing_required;
4594         gint text_len, number_len, tpdu_data_len;
4595         gchar* text, *dialling_number;
4596         GVariant *tpdu_data, *icon_id;
4597
4598         if(!display_status){
4599                 struct treq_sat_terminal_rsp_data *tr = NULL;
4600                 dbg("[SAT] fail to show ui display for send sms");
4601
4602                 tr = g_new0(struct treq_sat_terminal_rsp_data, 1);
4603
4604                 tr->cmd_number = q_data->cmd_data.sendSMSInd.command_detail.cmd_num;
4605                 tr->cmd_type = q_data->cmd_data.sendSMSInd.command_detail.cmd_type;
4606                 memcpy((void*)&tr->terminal_rsp_data.send_sms.command_detail, &q_data->cmd_data.sendSMSInd.command_detail, sizeof(struct tel_sat_cmd_detail_info));
4607
4608                 tr->terminal_rsp_data.send_sms.device_id.src = DEVICE_ID_ME;
4609                 tr->terminal_rsp_data.send_sms.device_id.dest = q_data->cmd_data.sendSMSInd.device_id.src;
4610                 tr->terminal_rsp_data.send_sms.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
4611
4612                 sat_manager_send_terminal_response(ctx->comm, plg, tr);
4613                 g_free(tr);
4614                 return TRUE;
4615         }
4616
4617         //emit send sms signal
4618         plg_name = (gchar *)tcore_server_get_cp_name_by_plugin(plg);
4619         if (plg_name) {
4620                 path = g_strdup_printf("%s/%s", MY_DBUS_PATH, plg_name);
4621         }
4622         else {
4623                 path = g_strdup_printf("%s", MY_DBUS_PATH);
4624         }
4625         dbg("path = [%s]", path);
4626
4627         object = g_hash_table_lookup(ctx->objects, path);
4628         sat = telephony_object_peek_sat(TELEPHONY_OBJECT(object));
4629
4630         send_sms = sat_manager_send_sms_noti(ctx, plg_name, &q_data->cmd_data.sendSMSInd);
4631
4632         dbg("send sms type_format(%s)", g_variant_get_type_string(send_sms));
4633         g_variant_get(send_sms, "(isi@vbiisii@vi)", &command_id, &text, &text_len, &icon_id, &b_packing_required, &ton, &npi,
4634                         &dialling_number, &number_len, &tpdu_type, &tpdu_data, &tpdu_data_len);
4635
4636         telephony_sat_emit_send_sms(sat, command_id, text, text_len, b_packing_required,
4637                         ton, npi, dialling_number, number_len, tpdu_type, tpdu_data, tpdu_data_len);
4638
4639         return TRUE;
4640 }
4641
4642 static gboolean _sat_manager_handle_send_ss_ui_display_status(struct custom_data *ctx, TcorePlugin *plg,struct sat_manager_queue_data *q_data, gboolean display_status)
4643 {
4644         char *path;
4645         TelephonySAT *sat;
4646         TelephonyObjectSkeleton *object;
4647
4648         gchar *plg_name = NULL;
4649         GVariant *send_ss = NULL;
4650
4651
4652         gint command_id, ton, npi;
4653         gint text_len, ss_str_len;
4654         gchar* text, *ss_string;
4655         GVariant *icon_id;
4656
4657         if(!display_status){
4658                 struct treq_sat_terminal_rsp_data *tr = NULL;
4659                 dbg("[SAT] fail to show ui display for send ss");
4660
4661                 tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
4662
4663                 tr->cmd_number = q_data->cmd_data.send_ss.command_detail.cmd_num;
4664                 tr->cmd_type = q_data->cmd_data.send_ss.command_detail.cmd_type;
4665                 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));
4666
4667                 tr->terminal_rsp_data.send_ss.device_id.src = DEVICE_ID_ME;
4668                 tr->terminal_rsp_data.send_ss.device_id.dest = q_data->cmd_data.send_ss.device_id.src;
4669                 tr->terminal_rsp_data.send_ss.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
4670
4671                 sat_manager_send_terminal_response(ctx->comm, plg, tr);
4672                 g_free(tr);
4673
4674                 return TRUE;
4675         }
4676
4677         //emit send ss signal
4678         plg_name = (gchar *)tcore_server_get_cp_name_by_plugin(plg);
4679         if (plg_name) {
4680                 path = g_strdup_printf("%s/%s", MY_DBUS_PATH, plg_name);
4681         }
4682         else {
4683                 path = g_strdup_printf("%s", MY_DBUS_PATH);
4684         }
4685         dbg("path = [%s]", path);
4686
4687         object = g_hash_table_lookup(ctx->objects, path);
4688         sat = telephony_object_peek_sat(TELEPHONY_OBJECT(object));
4689
4690         send_ss = sat_manager_send_ss_noti(ctx, plg_name, &q_data->cmd_data.send_ss);
4691
4692         dbg("send ss type_format(%s)", g_variant_get_type_string(send_ss));
4693         g_variant_get(send_ss, "(isi@viiis)", &command_id, &text, &text_len, &icon_id,
4694                         &ton, &npi, &ss_str_len, &ss_string);
4695
4696         telephony_sat_emit_send_ss(sat, command_id, text, text_len, ton, npi, ss_string);
4697         sat_ui_support_launch_ciss_application(SAT_PROATV_CMD_SEND_SS, send_ss);
4698
4699         return TRUE;
4700 }
4701
4702 static gboolean _sat_manager_handle_send_ussd_ui_display_status(struct custom_data *ctx, TcorePlugin *plg,struct sat_manager_queue_data *q_data, gboolean display_status)
4703 {
4704         char *path;
4705         TelephonySAT *sat;
4706         TelephonyObjectSkeleton *object;
4707
4708         gchar *plg_name = NULL;
4709         GVariant *send_ussd = NULL;
4710
4711         gint command_id;
4712         gint text_len, ussd_str_len;
4713         gchar* text, *ussd_string;
4714         GVariant *icon_id;
4715
4716         if(!display_status){
4717                 struct treq_sat_terminal_rsp_data *tr = NULL;
4718                 dbg("[SAT] fail to show ui display for send ussd");
4719
4720                 tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
4721
4722                 tr->cmd_number = q_data->cmd_data.send_ussd.command_detail.cmd_num;
4723                 tr->cmd_type = q_data->cmd_data.send_ussd.command_detail.cmd_type;
4724                 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));
4725
4726                 tr->terminal_rsp_data.send_ussd.device_id.src = DEVICE_ID_ME;
4727                 tr->terminal_rsp_data.send_ussd.device_id.dest = q_data->cmd_data.send_ussd.device_id.src;
4728                 tr->terminal_rsp_data.send_ussd.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
4729
4730                 sat_manager_send_terminal_response(ctx->comm, plg, tr);
4731                 g_free(tr);
4732
4733                 return TRUE;
4734         }
4735
4736         /* emit send ussd signal */
4737         plg_name = (gchar *)tcore_server_get_cp_name_by_plugin(plg);
4738         if (plg_name) {
4739                 path = g_strdup_printf("%s/%s", MY_DBUS_PATH, plg_name);
4740         }
4741         else {
4742                 path = g_strdup_printf("%s", MY_DBUS_PATH);
4743         }
4744         dbg("path = [%s]", path);
4745
4746         object = g_hash_table_lookup(ctx->objects, path);
4747         sat = telephony_object_peek_sat(TELEPHONY_OBJECT(object));
4748
4749         send_ussd = sat_manager_send_ussd_noti(ctx, plg_name, &q_data->cmd_data.send_ussd);
4750
4751         dbg("send ussd type_format(%s)", g_variant_get_type_string(send_ussd));
4752         g_variant_get(send_ussd, "(isi@vis)", &command_id, &text, &text_len, &icon_id, &ussd_str_len, &ussd_string);
4753
4754         telephony_sat_emit_setup_ussd(sat, command_id, text, text_len, ussd_string);
4755         sat_ui_support_launch_ciss_application(SAT_PROATV_CMD_SEND_USSD, send_ussd);
4756
4757         return TRUE;
4758 }
4759
4760 static gboolean _sat_manager_handle_setup_idle_mode_text_ui_display_status(struct custom_data *ctx, TcorePlugin *plg,struct sat_manager_queue_data *q_data, gboolean display_status)
4761 {
4762         TReturn rv = TCORE_RETURN_FAILURE;
4763         gboolean result = FALSE;
4764
4765         struct treq_sat_terminal_rsp_data *tr;
4766
4767         if (!plg){
4768                 dbg("there is no valid plugin at this point");
4769                 return result;
4770         }
4771
4772         tr = g_new0(struct treq_sat_terminal_rsp_data, 1);
4773         tr->cmd_number = q_data->cmd_data.idle_mode.command_detail.cmd_num;
4774         tr->cmd_type = q_data->cmd_data.idle_mode.command_detail.cmd_type;
4775         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));
4776         tr->terminal_rsp_data.setup_idle_mode_text.device_id.src = q_data->cmd_data.idle_mode.device_id.dest;
4777         tr->terminal_rsp_data.setup_idle_mode_text.device_id.dest = q_data->cmd_data.idle_mode.device_id.src;
4778
4779         tr->terminal_rsp_data.setup_idle_mode_text.result_type = RESULT_SUCCESS;
4780                 if (q_data->cmd_data.idle_mode.icon_id.icon_info.ics == IMAGE_CODING_SCHEME_COLOUR)
4781                                 tr->terminal_rsp_data.setup_idle_mode_text.result_type = RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED;
4782
4783         //fail to display text
4784         if(!display_status){
4785                 dbg("[SAT] fail to show ui display for setup_idle_mode_text");
4786                 tr->terminal_rsp_data.setup_idle_mode_text.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
4787         }
4788
4789         result = TRUE;
4790         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
4791         if(rv != TCORE_RETURN_SUCCESS){
4792                 dbg("fail to send terminal response");
4793                 result = FALSE;
4794         }
4795         g_free(tr);
4796
4797         sat_ui_support_terminate_sat_ui();
4798
4799         return result;
4800 }
4801
4802 static gboolean _sat_manager_handle_refresh_ui_display_status(struct custom_data *ctx, TcorePlugin *plg,struct sat_manager_queue_data *q_data, gboolean display_status)
4803 {
4804         struct treq_sat_terminal_rsp_data tr;
4805
4806         memset(&tr, 0, sizeof(struct treq_sat_terminal_rsp_data));
4807
4808         tr.cmd_number = q_data->cmd_data.refresh.command_detail.cmd_num;
4809         tr.cmd_type = q_data->cmd_data.refresh.command_detail.cmd_type;
4810         memcpy((void*)&tr.terminal_rsp_data.refresh.command_detail, &q_data->cmd_data.refresh.command_detail, sizeof(struct tel_sat_cmd_detail_info));
4811         tr.terminal_rsp_data.refresh.device_id.src = q_data->cmd_data.refresh.device_id.dest;
4812         tr.terminal_rsp_data.refresh.device_id.dest = q_data->cmd_data.refresh.device_id.src;
4813
4814         if(!display_status){
4815                 dbg("fail to show ui for refresh");
4816                 tr.terminal_rsp_data.refresh.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
4817         }
4818         else{
4819                 dbg("success to show ui for refresh");
4820                 tr.terminal_rsp_data.more_time.result_type = RESULT_SUCCESS;
4821                 tr.terminal_rsp_data.more_time.me_problem_type = ME_PROBLEM_NO_SPECIFIC_CAUSE;
4822         }
4823
4824         dbg("send refresh tr");
4825         sat_manager_send_terminal_response(ctx->comm, plg, &tr);
4826         return TRUE;
4827 }
4828
4829 static gboolean _sat_manager_handle_send_dtmf_ui_display_status(struct custom_data *ctx, TcorePlugin *plg,struct sat_manager_queue_data *q_data, gboolean display_status)
4830 {
4831         char *path;
4832         TelephonySAT *sat;
4833         TelephonyObjectSkeleton *object;
4834
4835         gchar *plg_name = NULL;
4836
4837         GVariant *send_dtmf = NULL;
4838         gint command_id = 0;
4839         gint text_len = 0, dtmf_str_len = 0;
4840         gchar *text = NULL;
4841         gchar *dtmf_str = NULL;
4842         GVariant *icon_id = NULL;
4843
4844         if(!display_status){
4845                 struct treq_sat_terminal_rsp_data *tr = NULL;
4846                 dbg("[SAT] fail to show ui display for send_dtmf");
4847
4848                 tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
4849
4850                 tr->cmd_number = q_data->cmd_data.send_dtmf.command_detail.cmd_num;
4851                 tr->cmd_type = q_data->cmd_data.send_dtmf.command_detail.cmd_type;
4852                 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));
4853
4854                 tr->terminal_rsp_data.send_dtmf.device_id.src = DEVICE_ID_ME;
4855                 tr->terminal_rsp_data.send_dtmf.device_id.dest = q_data->cmd_data.send_dtmf.device_id.src;
4856                 tr->terminal_rsp_data.send_dtmf.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
4857
4858                 sat_manager_send_terminal_response(ctx->comm, plg, tr);
4859                 g_free(tr);
4860
4861                 return TRUE;
4862         }
4863
4864         //emit send_dtmf signal
4865         plg_name = (gchar *)tcore_server_get_cp_name_by_plugin(plg);
4866         if (plg_name) {
4867                 path = g_strdup_printf("%s/%s", MY_DBUS_PATH, plg_name);
4868         } else {
4869                 path = g_strdup_printf("%s", MY_DBUS_PATH);
4870         }
4871         dbg("path = [%s]", path);
4872
4873         object = g_hash_table_lookup(ctx->objects, path);
4874         sat = telephony_object_peek_sat(TELEPHONY_OBJECT(object));
4875
4876         send_dtmf = sat_manager_send_dtmf_noti(ctx, plg_name, &q_data->cmd_data.send_dtmf);
4877
4878         dbg("send_dtmf type_format(%s)", g_variant_get_type_string(send_dtmf));
4879         g_variant_get(send_dtmf, "(isi@vis)", &command_id, &text, &text_len, &icon_id, &dtmf_str_len, &dtmf_str);
4880
4881         telephony_sat_emit_send_dtmf(sat, command_id, text, text_len, dtmf_str, dtmf_str_len);
4882
4883         return TRUE;
4884 }
4885
4886 static gboolean _sat_manager_handle_open_channel_ui_display_status(struct custom_data *ctx, TcorePlugin *plg,struct sat_manager_queue_data *q_data, gboolean display_status)
4887 {
4888         char *path;
4889         TelephonyObjectSkeleton *object;
4890
4891         gchar *plg_name = NULL;
4892
4893         GVariant *open_channel = NULL;
4894
4895         gint command_id, bearer_type, protocol_type, dest_addr_type;
4896         gboolean immediate_link, auto_reconnection, bg_mode;
4897         gint text_len, buffer_size, port_number;
4898         gchar *text, *dest_address;
4899         GVariant *icon_id;
4900         GVariant *bearer_param;
4901         GVariant *bearer_detail;
4902
4903         if(!display_status){
4904                 struct treq_sat_terminal_rsp_data *tr = NULL;
4905                 dbg("[SAT] fail to show ui display for open channel");
4906
4907                 tr = (struct treq_sat_terminal_rsp_data *)calloc(1, sizeof(struct treq_sat_terminal_rsp_data));
4908
4909                 tr->cmd_number = q_data->cmd_data.open_channel.command_detail.cmd_num;
4910                 tr->cmd_type = q_data->cmd_data.open_channel.command_detail.cmd_type;
4911                 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));
4912
4913                 tr->terminal_rsp_data.open_channel.device_id.src = q_data->cmd_data.send_dtmf.device_id.dest;
4914                 tr->terminal_rsp_data.open_channel.device_id.dest = q_data->cmd_data.send_dtmf.device_id.src;
4915                 tr->terminal_rsp_data.open_channel.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
4916
4917                 sat_manager_send_terminal_response(ctx->comm, plg, tr);
4918                 g_free(tr);
4919
4920                 return TRUE;
4921         }
4922
4923         //emit send_dtmf signal
4924         plg_name = (gchar *)tcore_server_get_cp_name_by_plugin(plg);
4925         if (plg_name) {
4926                 path = g_strdup_printf("%s/%s", MY_DBUS_PATH, plg_name);
4927         } else {
4928                 path = g_strdup_printf("%s", MY_DBUS_PATH);
4929         }
4930         dbg("path = [%s]", path);
4931
4932         object = g_hash_table_lookup(ctx->objects, path);
4933
4934         open_channel = sat_manager_open_channel_noti(ctx, plg_name, &q_data->cmd_data.open_channel);
4935
4936         dbg("open channel type_format(%s)", g_variant_get_type_string(open_channel));
4937         g_variant_get(open_channel,"(isi@vbbbi@viiiis@v)", &command_id, &text, &text_len, &icon_id, &immediate_link, &auto_reconnection, &bg_mode,
4938                         &bearer_type, &bearer_param, &buffer_size, &protocol_type, &port_number, &dest_addr_type, &dest_address, &bearer_detail);
4939
4940         /*telephony_sat_emit_open_channel(sat, command_id, text, text_len, immediate_link, auto_reconnection, bg_mode,
4941                         bearer_type, bearer_param, buffer_size, protocol_type, port_number, dest_addr_type, dest_address, bearer_detail);*/
4942
4943         //BIP Manager
4944         {
4945                 gboolean b_sig = FALSE;
4946                 GDBusConnection *conn = NULL;
4947                 const gchar *g_path = NULL;
4948
4949                 conn = g_dbus_object_manager_server_get_connection(ctx->manager);
4950                 g_path = g_dbus_object_get_object_path(G_DBUS_OBJECT(object));
4951
4952                 b_sig = sat_ui_support_exec_bip(conn, g_path, SAT_PROATV_CMD_OPEN_CHANNEL, open_channel);
4953         }
4954
4955         return TRUE;
4956 }
4957
4958 gboolean sat_manager_handle_ui_display_status(struct custom_data *ctx, TcorePlugin *plg, gint command_id, gboolean display_status)
4959 {
4960         gboolean result = FALSE;
4961         struct sat_manager_queue_data q_data;
4962
4963         dbg("[SAT] ui display status : command id(%d) display status(%d)", command_id, display_status);
4964         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
4965
4966         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
4967                 dbg("[SAT] command peek data from queue is failed. didn't find in command Q!!");
4968                 return result;
4969         }
4970
4971         if (!plg){
4972                 dbg("there is no valid plugin at this point");
4973                 return result;
4974         }
4975
4976         switch(q_data.cmd_type){
4977                 case SAT_PROATV_CMD_PLAY_TONE:
4978                         result = _sat_manager_handle_play_tone_ui_display_status(ctx, plg, &q_data, display_status);
4979                         break;
4980                 case SAT_PROATV_CMD_SEND_SMS:
4981                         result = _sat_manager_handle_send_sms_ui_display_status(ctx, plg, &q_data, display_status);
4982                         break;
4983                 case SAT_PROATV_CMD_SEND_SS:
4984                         result = _sat_manager_handle_send_ss_ui_display_status(ctx, plg, &q_data, display_status);
4985                         break;
4986                 case SAT_PROATV_CMD_SEND_USSD:
4987                         result = _sat_manager_handle_send_ussd_ui_display_status(ctx, plg, &q_data, display_status);
4988                         break;
4989                 case SAT_PROATV_CMD_SETUP_IDLE_MODE_TEXT:
4990                         result = _sat_manager_handle_setup_idle_mode_text_ui_display_status(ctx, plg, &q_data, display_status);
4991                         break;
4992                 case SAT_PROATV_CMD_REFRESH:
4993                         result = _sat_manager_handle_refresh_ui_display_status(ctx, plg, &q_data, display_status);
4994                         break;
4995                 case SAT_PROATV_CMD_SEND_DTMF:
4996                         result = _sat_manager_handle_send_dtmf_ui_display_status(ctx, plg, &q_data, display_status);
4997                         break;
4998                 case SAT_PROATV_CMD_OPEN_CHANNEL:
4999                         result = _sat_manager_handle_open_channel_ui_display_status(ctx, plg, &q_data, display_status);
5000                         break;
5001                 default:
5002                         dbg("[SAT] cannot handle ui display status command(0x%x)", q_data.cmd_type);
5003                         break;
5004         }
5005
5006         return result;
5007 }
5008
5009 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)
5010 {
5011         GVariant *data = NULL;
5012
5013         dbg("download data type_format(%s)", g_variant_get_type_string(download_data));
5014         g_variant_get(download_data, "v", &data);
5015
5016         switch(event_type)
5017         {
5018                 case EVENT_USER_ACTIVITY:
5019                         dbg("data type_format(%s)", g_variant_get_type_string(data));
5020                         evt_download->device_identitie.src = src_dev;
5021                         evt_download->device_identitie.dest = dest_dev;
5022                         break;
5023                 case EVENT_IDLE_SCREEN_AVAILABLE:
5024                         dbg("data type_format(%s)", g_variant_get_type_string(data));
5025                         g_variant_get(data, "(b)", &evt_download->idle_screen);
5026                         evt_download->device_identitie.src = DEVICE_ID_DISPLAY;
5027                         evt_download->device_identitie.dest = dest_dev;
5028                         dbg("idle screen available (%d)", evt_download->idle_screen);
5029                         break;
5030                 case EVENT_LANGUAGE_SELECTION:
5031                         dbg("data type_format(%s)", g_variant_get_type_string(data));
5032                         g_variant_get(data, "(i)", &evt_download->language);
5033                         evt_download->device_identitie.src = src_dev;
5034                         evt_download->device_identitie.dest = dest_dev;
5035                         dbg("selected language (%d)", evt_download->language);
5036                         break;
5037                 case EVENT_BROWSER_TERMINATION:{
5038                         dbg("data type_format(%s)", g_variant_get_type_string(data));
5039                         g_variant_get(data, "(i)", &evt_download->browser_termination);
5040                         evt_download->device_identitie.src = src_dev;
5041                         evt_download->device_identitie.dest = dest_dev;
5042                         dbg("browser termination cause(%d)", evt_download->browser_termination);
5043                 } break;
5044                 case EVENT_DATA_AVAILABLE:{
5045                         gint channel_id, channel_status, channel_info, channel_data_len;
5046
5047                         dbg("data type_format(%s)", g_variant_get_type_string(data));
5048                         g_variant_get(data, "(iiii)", &channel_id, &channel_status, &channel_info, &channel_data_len);
5049                         evt_download->device_identitie.src = src_dev;
5050                         evt_download->device_identitie.dest = dest_dev;
5051                         evt_download->channel_status.channel_id = channel_id;
5052                         evt_download->channel_status.status = channel_status;
5053                         evt_download->channel_status.status_info = channel_info;
5054                         evt_download->channel_data_len.data_len = channel_data_len;
5055                         dbg("data available channel id (%d)", evt_download->channel_status.channel_id);
5056                 } break;
5057                 case EVENT_CHANNEL_STATUS:{
5058                         gint channel_id, channel_status, channel_info;
5059
5060                         dbg("data type_format(%s)", g_variant_get_type_string(data));
5061                         g_variant_get(data, "(iii)", &channel_id, &channel_status, &channel_info);
5062                         evt_download->device_identitie.src = src_dev;
5063                         evt_download->device_identitie.dest = dest_dev;
5064                         evt_download->channel_status.channel_id = channel_id;
5065                         evt_download->channel_status.status = channel_status;
5066                         evt_download->channel_status.status_info = channel_info;
5067
5068                 } break;
5069                 default :
5070                         dbg("not support download event (%d)", event_type);
5071                         break;
5072         }
5073
5074         return TRUE;
5075 }
5076
5077 gboolean sat_manager_update_language(struct custom_data *ctx, const char *plugin_name, GVariant *language_noti)
5078 {
5079         Server *s = NULL;
5080         TcorePlugin *plg = NULL;
5081         gpointer handle = NULL;
5082         static Storage *strg;
5083
5084         TReturn rv = TCORE_RETURN_FAILURE;
5085         gboolean result = FALSE;
5086         const gchar *lang_str = NULL;
5087         gint command_id, language;
5088         gboolean b_specified;
5089
5090         struct treq_sat_terminal_rsp_data *tr;
5091         struct sat_manager_queue_data q_data;
5092
5093         s = ctx->server;
5094         strg = tcore_server_find_storage(s, "vconf");
5095         handle = tcore_storage_create_handle(strg, "vconf");
5096         if (!handle){
5097                 err("fail to create vconf handle");
5098                 return result;
5099         }
5100
5101         plg = tcore_server_find_plugin(ctx->server, plugin_name);
5102         if (!plg){
5103                 dbg("there is no valid plugin at this point");
5104                 return result;
5105         }
5106
5107         memset(&q_data, 0, sizeof(struct sat_manager_queue_data));
5108
5109         dbg("language_noti type_format(%s)", g_variant_get_type_string(language_noti));
5110         g_variant_get(language_noti, "(iib)", &command_id, &language, &b_specified);
5111
5112         if (sat_manager_dequeue_cmd_by_id(ctx, &q_data, command_id) == FALSE) {
5113                 dbg("[SAT] command dequeue failed. didn't find in command Q!!");
5114                 return result;
5115         }
5116
5117         if(q_data.cmd_type != SAT_PROATV_CMD_LANGUAGE_NOTIFICATION){
5118                 dbg("[SAT] Language Noti dequeue failed. didn't find in command Q!!");
5119                 return result;
5120         }
5121
5122         tr = g_new0(struct treq_sat_terminal_rsp_data, 1);
5123         tr->cmd_number = q_data.cmd_data.language_notification.command_detail.cmd_num;
5124         tr->cmd_type = q_data.cmd_data.language_notification.command_detail.cmd_type;
5125         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));
5126         tr->terminal_rsp_data.language_notification.device_id.src = DEVICE_ID_ME;
5127         tr->terminal_rsp_data.language_notification.device_id.dest = DEVICE_ID_SIM;
5128         tr->terminal_rsp_data.language_notification.result_type = RESULT_SUCCESS;
5129
5130         lang_str = _convert_sim_lang_to_string((enum tel_sim_language_type)language);
5131         if(!lang_str){
5132                 dbg("language is not exist");
5133                 tr->terminal_rsp_data.language_notification.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
5134         }
5135         dbg("converted lang (%s)", lang_str);
5136
5137         result = tcore_storage_set_string(strg,STORAGE_KEY_LANGUAGE_SET, (const char*)lang_str);
5138         if(!result){
5139                 dbg("fail to update language");
5140                 tr->terminal_rsp_data.language_notification.result_type = RESULT_ME_UNABLE_TO_PROCESS_COMMAND;
5141         }
5142
5143         result = TRUE;
5144         rv = sat_manager_send_terminal_response(ctx->comm, plg, tr);
5145         if(rv != TCORE_RETURN_SUCCESS){
5146                 dbg("fail to send terminal response");
5147                 result = FALSE;
5148         }
5149
5150         g_free(tr);
5151         return result;
5152 }