src/tapi_common.c

   1 /*
   2  * libslp-tapi
   3  *
   4  * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Ja-young Gu <jygu@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */
  20
  21 #define _GNU_SOURCE
  22 #include <errno.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26
  27 #include <glib.h>
  28 #include <gio/gio.h>
  29
  30 #include "tapi_common.h"
  31 #include "TapiUtility.h"
  32
  33 #include "TelNetwork.h"
  34 #include "TelSms.h"
  35 #include "TelSat.h"
  36 #include "TelSs.h"
  37 #include "TelCall.h"
  38
  39 #include "common.h"
  40 #include "tapi_log.h"
  41
  42 extern char *g_cookie_name;
  43 extern int g_cookie_size;
  44
  45 TelSatEventDownloadType_t g_event_list[TAPI_SAT_EVENT_LIST_MAX_COUNT] = {-1};
  46
  47 static void _process_sms_event(const gchar *sig, GVariant *param,
  48         TapiHandle *handle, char *noti_id, struct tapi_evt_cb *evt_cb_data)
  49 {
  50         TAPI_RETURN_IF_FAIL(evt_cb_data);
  51
  52         if (!g_strcmp0(sig, "IncommingMsg")) {
  53                 struct tel_noti_sms_incomming_msg noti;
  54
  55                 GVariant *sca = 0, *tpdu = 0;
  56                 int i = 0;
  57                 GVariantIter *iter = 0;
  58                 GVariant *inner_gv = 0;
  59
  60                 memset(&noti, 0, sizeof(struct tel_noti_sms_incomming_msg));
  61
  62                 g_variant_get(param, "(@vi@v)", &sca, &noti.MsgLength, &tpdu);
  63
  64                 inner_gv = g_variant_get_variant( sca );
  65                 g_variant_get(inner_gv, "ay", &iter);
  66                 while( g_variant_iter_loop( iter, "y", &noti.Sca[i] ) ) {
  67                          i++;
  68                          if( i >= TAPI_SIM_SMSP_ADDRESS_LEN )
  69                                  break;
  70                 }
  71
  72                 i = 0;
  73                 inner_gv = g_variant_get_variant( tpdu );
  74                 g_variant_get(inner_gv, "ay", &iter);
  75                 while( g_variant_iter_loop( iter, "y", &noti.szData[i] ) ) {
  76                          i++;
  77                          if( i >= TAPI_NETTEXT_SMDATA_SIZE_MAX + 1 )
  78                                 break;
  79                 }
  80                 g_variant_iter_free(iter);
  81                 g_variant_unref(inner_gv);
  82
  83                 noti.format = TAPI_NETTEXT_NETTYPE_3GPP;
  84
  85                 CALLBACK_CALL(&noti);
  86         }
  87         else if (!g_strcmp0(sig, "IncommingCbMsg")) {
  88                 struct tel_noti_sms_incomming_cb_msg noti;
  89
  90                 GVariant *cbMsg = NULL;
  91                 int i = 0;
  92                 GVariantIter *iter = 0;
  93                 GVariant *inner_gv = 0;
  94
  95                 memset(&noti, 0, sizeof(struct tel_noti_sms_incomming_cb_msg));
  96                 g_variant_get(param, "(ii@v)", &noti.CbMsgType, &noti.Length, &cbMsg);
  97
  98                 inner_gv = g_variant_get_variant( cbMsg );
  99                 g_variant_get(inner_gv, "ay", &iter);
 100                 while( g_variant_iter_loop( iter, "y", &noti.szMsgData[i] ) ) {
 101                          i++;
 102                          if( i >= noti.Length + 1 )
 103                                  break;
 104                 }
 105                 g_variant_iter_free(iter);
 106                 g_variant_unref(inner_gv);
 107
 108                 CALLBACK_CALL(&noti);
 109         }
 110         else if (!g_strcmp0(sig, "IncommingEtwsMsg")) {
 111                 struct tel_noti_sms_incomming_etws_msg noti;
 112
 113                 GVariant *etwsMsg = NULL;
 114                 int i = 0;
 115                 GVariantIter *iter = 0;
 116                 GVariant *inner_gv = 0;
 117
 118
 119                 memset(&noti, 0, sizeof(struct tel_noti_sms_incomming_etws_msg));
 120                 g_variant_get(param, "(ii@v)", &noti.EtwsMsgType, &noti.Length, &etwsMsg);
 121
 122                 inner_gv = g_variant_get_variant( etwsMsg );
 123                 g_variant_get(inner_gv, "ay", &iter);
 124                 while( g_variant_iter_loop( iter, "y", &noti.szMsgData[i] ) ) {
 125                          i++;
 126                          if( i >= TAPI_NETTEXT_ETWS_SIZE_MAX + 1 )
 127                                  break;
 128                 }
 129                 g_variant_iter_free(iter);
 130                 g_variant_unref(inner_gv);
 131
 132                 CALLBACK_CALL(&noti);
 133         }
 134         else if (!g_strcmp0(sig, "MemoryStatus")) {
 135                 int noti = 0;
 136
 137                 g_variant_get(param, "(i)", &noti);
 138                 CALLBACK_CALL(&noti);
 139         }
 140         else if (!g_strcmp0(sig, "SmsReady")) {
 141                 gboolean noti = 0;
 142
 143                 g_variant_get(param, "(b)", &noti);
 144                 CALLBACK_CALL(&noti);
 145         }
 146         else {
 147                 dbg("not handled Sms noti[%s]", sig);
 148         }
 149 }
 150
 151 static void _process_call_event(const gchar *sig, GVariant *param,
 152         TapiHandle *handle, char *noti_id, struct tapi_evt_cb *evt_cb_data)
 153 {
 154         TAPI_RETURN_IF_FAIL(evt_cb_data);
 155
 156         if (!g_strcmp0(sig, "VoiceCallStatusIdle") || !g_strcmp0(sig, "VideoCallStatusIdle") ) {
 157                 TelCallStatusIdleNoti_t data;
 158                 int start_time = 0, end_time = 0;
 159                 g_variant_get(param, "(iiii)", &data.id, &data.cause, &start_time, &end_time);
 160                 msg("[ check ] (%s) %s : call_id(%d), end_cause(0x%x)", handle->cp_name, "Status Idle noti", data.id, data.cause);
 161                 CALLBACK_CALL(&data);
 162         }
 163         else if (!g_strcmp0(sig, "VoiceCallStatusDialing") || !g_strcmp0(sig, "VideoCallStatusDialing")) {
 164                 TelCallStatusDialingNoti_t data;
 165                 g_variant_get(param, "(i)", &data.id);
 166                 msg("[ check ] (%s) %s : call_id(%d)", handle->cp_name, "Status Dialing noti", data.id);
 167                 CALLBACK_CALL(&data);
 168         }
 169         else if (!g_strcmp0(sig, "VoiceCallStatusAlert") || !g_strcmp0(sig, "VideoCallStatusAlert")) {
 170                 TelCallStatusAlertNoti_t data;
 171                 g_variant_get(param, "(i)", &data.id);
 172                 msg("[ check ] (%s) %s : call_id(%d)", handle->cp_name, "Status Alert noti", data.id);
 173                 CALLBACK_CALL(&data);
 174         }
 175         else if (!g_strcmp0(sig, "VoiceCallStatusActive") || !g_strcmp0(sig, "VideoCallStatusActive")) {
 176                 TelCallStatusActiveNoti_t data;
 177                 g_variant_get(param, "(i)", &data.id);
 178                 msg("[ check ] (%s) %s : call_id(%d)", handle->cp_name, "Status Active noti", data.id);
 179                 CALLBACK_CALL(&data);
 180         }
 181         else if (!g_strcmp0(sig, "VoiceCallStatusHeld") ) {
 182                 TelCallStatusHeldNoti_t data;
 183                 g_variant_get(param, "(i)", &data.id);
 184                 msg("[ check ] (%s) %s : call_id(%d)", handle->cp_name, "Status Held noti", data.id);
 185                 CALLBACK_CALL(&data);
 186         }
 187         else if (!g_strcmp0(sig, "VoiceCallStatusIncoming") || !g_strcmp0(sig, "VideoCallStatusIncoming")) {
 188                 TelCallStatusIncomingNoti_t data;
 189                 g_variant_get(param, "(i)", &data.id);
 190                 msg("[ check ] (%s) %s : call_id(%d)", handle->cp_name, "Status Incoming noti", data.id);
 191                 CALLBACK_CALL(&data);
 192         }
 193         else if (!g_strcmp0(sig, "Waiting")) {
 194                 TelCallInfoWaitingNoti_t data;
 195                 g_variant_get(param, "(i)", &data.id);
 196                 msg("[ check ] (%s) %s : data.id(%d)", handle->cp_name, "Call Info Waiting noti", data.id);
 197                 CALLBACK_CALL(&data.id);
 198         }
 199         else if (!g_strcmp0(sig, "Forwarded")) {
 200                 TelCallInfoForwardedNoti_t data;
 201                 g_variant_get(param, "(i)", &data.id);
 202                 msg("[ check ] (%s) %s : data.id(%d)", handle->cp_name, "Call Info Forwarded noti", data.id);
 203                 CALLBACK_CALL(&data.id);
 204         }
 205         else if (!g_strcmp0(sig, "ForwardedCall")) {
 206                 TelCallInfoForwardedCallNoti_t data;
 207                 g_variant_get(param, "(i)", &data.id);
 208                 dbg("[ check ] (%s) %s : data.id(%d)", handle->cp_name, "Call Info Forwarded Call noti", data.id);
 209                 CALLBACK_CALL(&data.id);
 210         }
 211         else if (!g_strcmp0(sig, "BarredIncoming")) {
 212                 TelCallInfoBarredIncomingNoti_t data;
 213                 g_variant_get(param, "(i)", &data.id);
 214                 msg("[ check ] (%s) %s : data.id(%d)", handle->cp_name, "Call Info Barred Incoming noti", data.id);
 215                 CALLBACK_CALL(&data.id);
 216         }
 217         else if (!g_strcmp0(sig, "BarredOutgoing")) {
 218                 TelCallInfoBarredOutgoingNoti_t data;
 219                 g_variant_get(param, "(i)", &data.id);
 220                 msg("[ check ] (%s) %s : data.id(%d)", handle->cp_name, "Call Info Barred Outgoing noti", data.id);
 221                 CALLBACK_CALL(&data.id);
 222         }
 223         else if (!g_strcmp0(sig, "ForwardConditional")) {
 224                 TelCallInfoForwardConditionalNoti_t data;
 225                 g_variant_get(param, "(i)", &data.id);
 226                 msg("[ check ] (%s) %s : data.id(%d)", handle->cp_name, "Call Info Forward Conditional noti", data.id);
 227                 CALLBACK_CALL(&data.id);
 228         }
 229         else if (!g_strcmp0(sig, "ForwardUnconditional")) {
 230                 TelCallInfoForwardUnconditionalNoti_t data;
 231                 g_variant_get(param, "(i)", &data.id);
 232                 msg("[ check ] (%s) %s : data.id(%d)", handle->cp_name, "Call Info Forward Unconditional noti", data.id);
 233                 CALLBACK_CALL(&data.id);
 234         }
 235         else if (!g_strcmp0(sig, "CallActive")) {
 236                 TelCallInfoActiveNoti_t data;
 237                 g_variant_get(param, "(i)", &data.id);
 238                 msg("[ check ] (%s) %s : data.id(%d)", handle->cp_name, "Call Info Call Active noti", data.id);
 239                 CALLBACK_CALL(&data.id);
 240         }
 241         else if (!g_strcmp0(sig, "CallHeld")) {
 242                 TelCallInfoHeldNoti_t data;
 243                 g_variant_get(param, "(i)", &data.id);
 244                 msg("[ check ] (%s) %s : data.id(%d)", handle->cp_name, "Call Info Call Held noti", data.id);
 245                 CALLBACK_CALL(&data.id);
 246         }
 247         else if (!g_strcmp0(sig, "CallJoined")) {
 248                 TelCallInfoJoinedNoti_t data;
 249                 g_variant_get(param, "(i)", &data.id);
 250                 msg("[ check ] (%s) %s : data.id(%d)", handle->cp_name, "Call Info Call Joined noti", data.id);
 251                 CALLBACK_CALL(&data.id);
 252         }
 253         else if (!g_strcmp0(sig, "CallSoundPath")) {
 254                 TelCallSoundPathNoti_t data;
 255                 g_variant_get(param, "(i)", &data.path);
 256                 msg("[ check ] (%s) %s : path(%d)", handle->cp_name, "Call Sound Path noti", data.path);
 257                 CALLBACK_CALL(&data);
 258         }
 259         else if (!g_strcmp0(sig, "CallSoundRingbackTone")) {
 260                 TelCallSoundRingbackToneNoti_t status;
 261                 g_variant_get(param, "(i)", &status);
 262                 msg("[ check ] (%s) %s : status(%d)", handle->cp_name, "Call Sound Ringbacktone noti", status);
 263                 CALLBACK_CALL(&status);
 264         }
 265         else if (!g_strcmp0(sig, "CallSoundWbamr")) {
 266                 TelCallSoundWbamrNoti_t status;
 267                 g_variant_get(param, "(i)", &status);
 268                 msg("[ check ] (%s) %s : status(%d)", handle->cp_name, "Call Sound Wbamr noti", status);
 269                 CALLBACK_CALL(&status);
 270         }
 271         else if (!g_strcmp0(sig, "CallSoundNoiseReduction")) {
 272                 TelCallSoundNoiseReductionNoti_t data;
 273                 g_variant_get(param, "(i)", &data.status);
 274                 msg("[ check ] (%s) %s : status(%d)", handle->cp_name, "Call Sound Noise Reduction noti", data.status);
 275                 CALLBACK_CALL(&data);
 276         }
 277         else if (!g_strcmp0(sig, "CallSoundClockStatus")) {
 278                 gboolean data;
 279                 g_variant_get(param, "(b)", &data);
 280                 msg("[ check ] (%s) %s : status(%d)", handle->cp_name, "Call Sound Clock Status noti", data);
 281                 CALLBACK_CALL(&data);
 282         }
 283         else if (!g_strcmp0(sig, "CallPreferredVoiceSubscription")) {
 284                 TelCallPreferredVoiceSubsNoti_t data;
 285                 g_variant_get(param, "(i)", &data.preferred_subs);
 286                 dbg("[ check ] %s : Voice preferred_subs(%d)", "Call Preferred Voice Subscription noti", data.preferred_subs);
 287                 CALLBACK_CALL(&data);
 288         }
 289         else {
 290                 dbg("not handled Call noti[%s]", sig);
 291         }
 292 }
 293
 294 static void _process_sat_event(const gchar *sig, GVariant *param,
 295         TapiHandle *handle, char *noti_id, struct tapi_evt_cb *evt_cb_data)
 296 {
 297         TAPI_RETURN_IF_FAIL(evt_cb_data);
 298
 299         if (!g_strcmp0(sig, "SetupMenu")) {
 300                 TelSatSetupMenuInfo_t setup_menu;
 301
 302                 gchar *title = NULL;
 303                 gint command_id, item_cnt;
 304                 gboolean b_present, b_helpinfo, b_updated;
 305                 GVariant *items = NULL;
 306
 307 #if defined(TIZEN_SUPPORT_SAT_ICON)
 308                 GVariant *icon_id = NULL;
 309                 GVariant *icon_list = NULL;
 310                 int sat_index = 0, icon_index = 0;
 311                 GVariantIter *iter, *iter2;
 312                 GVariant *unbox = NULL;
 313                 /* Used to get icon data */
 314                 gboolean is_exist;
 315                 gint icon_quali, icon_identifier, width, height, ics, icon_data_len;
 316                 gchar *icon_data = NULL;
 317                 /* Used to get icon list data */
 318                 GVariant *unbox_list, *unbox_list_info ;
 319                 GVariant *icon_list_info;
 320                 gboolean is_list_exist;
 321                 gint icon_list_quali, list_cnt, icon_list_identifier, list_width, list_height, list_ics, icon_list_data_len;
 322                 gchar *icon_list_data = NULL;
 323 #else
 324                 int sat_index = 0;
 325                 GVariant *unbox;
 326                 GVariantIter *iter;
 327 #endif
 328                 memset(&setup_menu, 0, sizeof(TelSatSetupMenuInfo_t));
 329
 330 #if defined(TIZEN_SUPPORT_SAT_ICON)
 331                 g_variant_get(param, "(ibs@vibb@v@v)", &command_id, &b_present, &title, &items, &item_cnt,
 332                                         &b_helpinfo, &b_updated, &icon_id, &icon_list);
 333 #else
 334                 g_variant_get(param, "(ibs@vibb)", &command_id, &b_present, &title, &items, &item_cnt,
 335                         &b_helpinfo, &b_updated);
 336 #endif
 337
 338                 setup_menu.commandId = command_id;
 339                 setup_menu.bIsMainMenuPresent = (b_present ? 1 : 0);
 340                 memcpy(setup_menu.satMainTitle, title, TAPI_SAT_DEF_TITLE_LEN_MAX+1);
 341                 g_free(title);
 342                 setup_menu.satMainMenuNum = item_cnt;
 343                 if(items && item_cnt > 0){
 344                         gchar *item_str;
 345                         gint item_id;
 346                         unbox = g_variant_get_variant(items);
 347                         dbg("items(%p) items type_format(%s)", items, g_variant_get_type_string(unbox));
 348
 349                         g_variant_get(unbox, "a(si)", &iter);
 350                         while(g_variant_iter_loop(iter,"(si)",&item_str, &item_id)){
 351                                 setup_menu.satMainMenuItem[sat_index].itemId = item_id;
 352                                 memcpy(setup_menu.satMainMenuItem[sat_index].itemString, item_str, TAPI_SAT_DEF_ITEM_STR_LEN_MAX + 6);
 353                                 dbg("item index(%d) id(%d) str(%s)",sat_index, setup_menu.satMainMenuItem[sat_index].itemId, setup_menu.satMainMenuItem[sat_index].itemString);
 354                                 //dbg("item index(%d) id(%d) str(%s)",index, item_id, item_str);
 355                                 sat_index++;
 356                         }
 357                         g_variant_iter_free(iter);
 358                 }
 359                 setup_menu.bIsSatMainMenuHelpInfo = (b_helpinfo ? 1 : 0);
 360                 setup_menu.bIsUpdatedSatMainMenu = (b_updated ? 1 : 0);
 361
 362 #if defined(TIZEN_SUPPORT_SAT_ICON)
 363                 if(icon_id) {
 364                         unbox = g_variant_get_variant(icon_id);
 365                         g_variant_get(unbox, "a(biiiiiis)", &iter);
 366
 367                         while(g_variant_iter_loop(iter,"(biiiiiis)", &is_exist, &icon_quali, &icon_identifier, &width, &height, &ics, &icon_data_len, &icon_data)){
 368                                 if(!is_exist)
 369                                         break;
 370                                 setup_menu.iconId.bIsPresent = is_exist;
 371                                 setup_menu.iconId.iconQualifier = icon_quali;
 372                                 setup_menu.iconId.iconIdentifier = icon_identifier;
 373                                 setup_menu.iconId.iconInfo.width = width;
 374                                 setup_menu.iconId.iconInfo.height = height;
 375                                 setup_menu.iconId.iconInfo.ics = ics;
 376                                 if(icon_data_len > 0) {
 377                                         setup_menu.iconId.iconInfo.iconDataLen = icon_data_len;
 378                                         memcpy(setup_menu.iconId.iconInfo.iconFile, icon_data, icon_data_len);
 379                                 }
 380                                 dbg("icon exist(%d), icon_quali: (%d), icon_id: (%d), width: (%d), height: (%d), ics: (%d), icon_data_len: (%d)", setup_menu.iconId.bIsPresent, setup_menu.iconId.iconQualifier, setup_menu.iconId.iconIdentifier, setup_menu.iconId.iconInfo.width,
 381                                         setup_menu.iconId.iconInfo.height, setup_menu.iconId.iconInfo.ics, setup_menu.iconId.iconInfo.iconDataLen);
 382                         }
 383                         g_variant_iter_free(iter);
 384                 }
 385
 386                 if(icon_list){
 387                         unbox_list = g_variant_get_variant(icon_list);
 388                         g_variant_get(unbox_list, "a(biiv)", &iter);
 389
 390                         while(g_variant_iter_loop(iter,"(biiv)", &is_list_exist, &icon_list_quali, &list_cnt, &icon_list_info)){
 391                                 if(!is_list_exist)
 392                                         break;
 393                                 setup_menu.iconIdList.bIsPresent = is_list_exist;
 394                                 setup_menu.iconIdList.iconListQualifier = icon_list_quali;
 395                                 setup_menu.iconIdList.iconCount = list_cnt;
 396
 397                                 unbox_list_info = g_variant_get_variant(icon_list_info);
 398                                 g_variant_get(unbox_list_info, "a(iiiiis)", &iter2);
 399
 400                                 while(g_variant_iter_loop(iter2,"(iiiiis)",&icon_list_identifier, &list_width, &list_height, &list_ics, &icon_list_data_len, &icon_list_data)){
 401                                         setup_menu.iconIdList.iconIdentifierList[icon_index]= icon_identifier;
 402                                         setup_menu.iconIdList.iconInfo[icon_index].width = list_width;
 403                                         setup_menu.iconIdList.iconInfo[icon_index].height = list_height;
 404                                         setup_menu.iconIdList.iconInfo[icon_index].ics = list_ics;
 405                                         if(icon_list_data_len > 0) {
 406                                                 setup_menu.iconIdList.iconInfo[icon_index].iconDataLen = icon_list_data_len;
 407                                                 memcpy(setup_menu.iconIdList.iconInfo[icon_index].iconFile, icon_list_data, icon_list_data_len);
 408                                         }
 409                                         icon_index++;
 410                                 }
 411                                 g_variant_iter_free(iter2);
 412                         }
 413                         g_variant_iter_free(iter);
 414                 }
 415 #endif
 416                 dbg("command id (%d)", setup_menu.commandId);
 417                 dbg("menu present (%d)", setup_menu.bIsMainMenuPresent);
 418                 dbg("menu title (%s)", setup_menu.satMainTitle);
 419                 dbg("item cnt (%d)", setup_menu.satMainMenuNum);
 420                 dbg("menu help info (%d)", setup_menu.bIsSatMainMenuHelpInfo);
 421                 dbg("menu updated (%d)", setup_menu.bIsUpdatedSatMainMenu);
 422
 423                 dbg("icon exist(%d), icon_quali: (%d), icon_id: (%d), width: (%d), height: (%d), ics: (%d), icon_data_len: (%d)", setup_menu.iconId.bIsPresent, setup_menu.iconId.iconQualifier, setup_menu.iconId.iconIdentifier, setup_menu.iconId.iconInfo.width,
 424                         setup_menu.iconId.iconInfo.height, setup_menu.iconId.iconInfo.ics, setup_menu.iconId.iconInfo.iconDataLen);
 425
 426                 CALLBACK_CALL(&setup_menu);
 427         }
 428         else if (!g_strcmp0(sig, "DisplayText")) {
 429                 TelSatDisplayTextInd_t display_text;
 430                 gchar* text;
 431                 gint command_id, text_len, duration;
 432                 gboolean high_priority, user_rsp_required, immediately_rsp;
 433
 434 #if defined(TIZEN_SUPPORT_SAT_ICON)
 435                 GVariant *unbox = NULL;
 436                 gboolean is_exist;
 437                 gint icon_quali, icon_identifier, width, height, ics, icon_data_len;
 438                 gchar *icon_data = NULL;
 439                 GVariant *icon_id = NULL;
 440                 GVariantIter *iter;
 441 #endif
 442                 memset(&display_text, 0, sizeof(TelSatDisplayTextInd_t));
 443
 444 #if defined(TIZEN_SUPPORT_SAT_ICON)
 445                 g_variant_get(param, "(isiibbb@v)", &command_id, &text, &text_len, &duration,
 446                         &high_priority, &user_rsp_required, &immediately_rsp, &icon_id);
 447 #else
 448                 g_variant_get(param, "(isiibbb)", &command_id, &text, &text_len, &duration,
 449                         &high_priority, &user_rsp_required, &immediately_rsp);
 450 #endif
 451                 display_text.commandId = command_id;
 452                 memcpy(display_text.text.string, text, TAPI_SAT_DEF_TEXT_STRING_LEN_MAX+1);
 453                 g_free(text);
 454                 display_text.text.stringLen = text_len;
 455                 display_text.duration = duration;
 456                 display_text.bIsPriorityHigh = (high_priority ? 1 : 0);
 457                 display_text.bIsUserRespRequired = (user_rsp_required ? 1 : 0);
 458                 display_text.b_immediately_resp = (immediately_rsp ? 1 : 0);
 459
 460 #if defined(TIZEN_SUPPORT_SAT_ICON)
 461                 if(icon_id) {
 462                         unbox = g_variant_get_variant(icon_id);
 463                         g_variant_get(unbox, "a(biiiiiis)", &iter);
 464
 465                         while(g_variant_iter_loop(iter,"(biiiiiis)", &is_exist, &icon_quali, &icon_identifier, &width, &height, &ics, &icon_data_len, &icon_data)) {
 466                                 if(!is_exist)
 467                                         break;
 468                                 display_text.iconId.bIsPresent = is_exist;
 469                                 display_text.iconId.iconQualifier = icon_quali;
 470                                 display_text.iconId.iconIdentifier = icon_identifier;
 471                                 display_text.iconId.iconInfo.width = width;
 472                                 display_text.iconId.iconInfo.height = height;
 473                                 display_text.iconId.iconInfo.ics = ics;
 474                                 if(icon_data_len > 0) {
 475                                         display_text.iconId.iconInfo.iconDataLen = icon_data_len;
 476                                         memcpy(display_text.iconId.iconInfo.iconFile, icon_data, icon_data_len);
 477                                 }
 478                                 dbg("icon exist(%d), icon_quali: (%d), icon_id: (%d), width: (%d), height: (%d), ics: (%d), icon_data_len: (%d)", display_text.iconId.bIsPresent, display_text.iconId.iconQualifier, display_text.iconId.iconIdentifier, display_text.iconId.iconInfo.width,
 479                                         display_text.iconId.iconInfo.height, display_text.iconId.iconInfo.ics, display_text.iconId.iconInfo.iconDataLen);
 480                         }
 481                         g_variant_iter_free(iter);
 482                 }
 483 #endif
 484                 dbg("command id (%d)", display_text.commandId);
 485                 dbg("display text (%s)", display_text.text.string);
 486                 dbg("string len(%d)", display_text.text.stringLen);
 487                 dbg("duration (%d)", display_text.duration);
 488                 dbg("high priority (%d)", display_text.bIsPriorityHigh);
 489                 dbg("user response required(%d)", display_text.bIsUserRespRequired);
 490                 dbg("immediately response (%d)", display_text.b_immediately_resp);
 491
 492                 CALLBACK_CALL(&display_text);
 493         }
 494         else if (!g_strcmp0(sig, "SelectItem")) {
 495                 TelSatSelectItemInd_t select_item;
 496
 497                 gboolean help_info ;
 498                 gchar *selected_text;
 499                 gint command_id, default_item_id, menu_cnt, text_len =0;
 500                 GVariant *menu_items;
 501 #if defined(TIZEN_SUPPORT_SAT_ICON)
 502                 GVariantIter *iter, *iter2;
 503                 GVariant *unbox = NULL;
 504                 gboolean is_exist;
 505                 gint icon_quali, icon_identifier, width, height, ics, icon_data_len;
 506                 gchar *icon_data = NULL;
 507                 GVariant *icon_id = NULL;
 508                 GVariant *icon_list = NULL;
 509                 int select_item_index = 0, icon_index = 0;
 510                 /* Used to get icon list data */
 511                 GVariant *unbox_list, *unbox_list_info ;
 512                 GVariant *icon_list_info;
 513                 gboolean is_list_exist;
 514                 gint icon_list_quali, list_cnt, icon_list_identifier, list_width, list_height, list_ics, icon_list_data_len;
 515                 gchar *icon_list_data = NULL;
 516 #else
 517                 int select_item_index = 0;
 518                 GVariant *unbox;
 519                 GVariantIter *iter;
 520 #endif
 521                 memset(&select_item, 0, sizeof(TelSatSelectItemInd_t));
 522
 523 #if defined(TIZEN_SUPPORT_SAT_ICON)
 524                 g_variant_get(param, "(ibsiii@v@v@v)", &command_id, &help_info, &selected_text,
 525                         &text_len, &default_item_id, &menu_cnt, &menu_items, &icon_id, &icon_list);
 526 #else
 527                 g_variant_get(param, "(ibsiii@v)", &command_id, &help_info, &selected_text,
 528                         &text_len, &default_item_id, &menu_cnt, &menu_items);
 529 #endif
 530                 select_item.commandId = command_id;
 531                 select_item.bIsHelpInfoAvailable = (help_info ? 1 : 0);
 532                 memcpy(select_item.text.string, selected_text, TAPI_SAT_DEF_TITLE_LEN_MAX+1);
 533                 g_free(selected_text);
 534                 select_item.text.stringLen = text_len;
 535                 select_item.defaultItemIndex = default_item_id;
 536                 select_item.menuItemCount = menu_cnt;
 537                 if(menu_items && menu_cnt > 0){
 538                         gchar *item_str;
 539                         gint item_id, item_len;
 540                         unbox = g_variant_get_variant(menu_items);
 541                         dbg("items(%p) items type_format(%s)", menu_items, g_variant_get_type_string(unbox));
 542
 543                         g_variant_get(unbox, "a(iis)", &iter);
 544                         while(g_variant_iter_loop(iter,"(iis)",&item_id, &item_len, &item_str)){
 545                                 select_item.menuItem[select_item_index].itemId = item_id;
 546                                 select_item.menuItem[select_item_index].textLen = item_len;
 547                                 memcpy(select_item.menuItem[select_item_index].text, item_str, TAPI_SAT_ITEM_TEXT_LEN_MAX + 1);
 548                                 dbg("item index(%d) id(%d) len(%d) str(%s)", select_item_index,
 549                                                 select_item.menuItem[select_item_index].itemId, select_item.menuItem[select_item_index].textLen, select_item.menuItem[select_item_index].text);
 550                                 select_item_index++;
 551                         }
 552                         g_variant_iter_free(iter);
 553                 }
 554
 555 #if defined(TIZEN_SUPPORT_SAT_ICON)
 556                 if(icon_id) {
 557                         unbox = g_variant_get_variant(icon_id);
 558                         g_variant_get(unbox, "a(biiiiiis)", &iter);
 559
 560                         while(g_variant_iter_loop(iter,"(biiiiiis)", &is_exist, &icon_quali, &icon_identifier, &width, &height, &ics, &icon_data_len, &icon_data)) {
 561                                 if(!is_exist)
 562                                         break;
 563                                 select_item.iconId.bIsPresent = is_exist;
 564                                 select_item.iconId.iconQualifier = icon_quali;
 565                                 select_item.iconId.iconIdentifier = icon_identifier;
 566                                 select_item.iconId.iconInfo.width = width;
 567                                 select_item.iconId.iconInfo.height = height;
 568                                 select_item.iconId.iconInfo.ics = ics;
 569                                 if(icon_data_len > 0) {
 570                                         select_item.iconId.iconInfo.iconDataLen = icon_data_len;
 571                                         memcpy(select_item.iconId.iconInfo.iconFile, icon_data, icon_data_len);
 572                                 }
 573                                 dbg("icon exist(%d), icon_quali: (%d), icon_id: (%d), width: (%d), height: (%d), ics: (%d), icon_data_len: (%d)", select_item.iconId.bIsPresent, select_item.iconId.iconQualifier, select_item.iconId.iconIdentifier, select_item.iconId.iconInfo.width,
 574                                                 select_item.iconId.iconInfo.height, select_item.iconId.iconInfo.ics, select_item.iconId.iconInfo.iconDataLen);
 575                         }
 576                         g_variant_iter_free(iter);
 577                 }
 578
 579                 if(icon_list){
 580                         unbox_list = g_variant_get_variant(icon_list);
 581                         g_variant_get(unbox_list, "a(biiv)", &iter);
 582
 583                         while(g_variant_iter_loop(iter,"(biiv)", &is_list_exist, &icon_list_quali, &list_cnt, &icon_list_info)) {
 584                                 if(!is_list_exist)
 585                                         break;
 586                                 select_item.iconIdList.bIsPresent = is_list_exist;
 587                                 select_item.iconIdList.iconListQualifier = icon_list_quali;
 588                                 select_item.iconIdList.iconCount = list_cnt;
 589
 590                                 unbox_list_info = g_variant_get_variant(icon_list_info);
 591                                 g_variant_get(unbox_list_info, "a(iiiiis)", &iter2);
 592
 593                                 while(g_variant_iter_loop(iter2,"(iiiiis)",&icon_list_identifier, &list_width, &list_height, &list_ics, &icon_list_data_len, &icon_list_data)){
 594                                         select_item.iconIdList.iconIdentifierList[icon_index]= icon_identifier;
 595                                         select_item.iconIdList.iconInfo[icon_index].width = list_width;
 596                                         select_item.iconIdList.iconInfo[icon_index].height = list_height;
 597                                         select_item.iconIdList.iconInfo[icon_index].ics = list_ics;
 598                                         if(icon_list_data_len > 0) {
 599                                                 select_item.iconIdList.iconInfo[icon_index].iconDataLen = icon_list_data_len;
 600                                                 memcpy(select_item.iconIdList.iconInfo[icon_index].iconFile, icon_list_data, icon_list_data_len);
 601                                         }
 602                                         icon_index++;
 603                                 }
 604                                 g_variant_iter_free(iter2);
 605                         }
 606                         g_variant_iter_free(iter);
 607                 }
 608 #endif
 609                 dbg("command id (%d)", select_item.commandId);
 610                 dbg("help info(%d)", select_item.bIsHelpInfoAvailable);
 611                 dbg("selected item string(%s)", select_item.text.string);
 612                 dbg("string len(%d)", select_item.text.stringLen);
 613                 dbg("default item index(%d)", select_item.defaultItemIndex);
 614                 dbg("item count(%d)", select_item.menuItemCount);
 615
 616                 CALLBACK_CALL(&select_item);
 617         }
 618         else if (!g_strcmp0(sig, "GetInkey")) {
 619                 TelSatGetInkeyInd_t get_inkey;
 620
 621                 gint command_id, key_type, input_character_mode;
 622                 gint text_len, duration;
 623                 gboolean b_numeric, b_help_info;
 624                 gchar *text = NULL;
 625 #if defined(TIZEN_SUPPORT_SAT_ICON)
 626                 GVariant *unbox = NULL;
 627                 gboolean is_exist;
 628                 gint icon_quali, icon_identifier, width, height, ics, icon_data_len;
 629                 gchar *icon_data = NULL;
 630                 GVariant *icon_id = NULL;
 631                 GVariantIter *iter;
 632 #endif
 633                 memset(&get_inkey, 0, sizeof(TelSatGetInkeyInd_t));
 634
 635 #if defined(TIZEN_SUPPORT_SAT_ICON)
 636                 g_variant_get(param, "(iiibbsii@v)", &command_id, &key_type, &input_character_mode,
 637                         &b_numeric,&b_help_info, &text, &text_len, &duration, &icon_id);
 638 #else
 639                 g_variant_get(param, "(iiibbsii)", &command_id, &key_type, &input_character_mode,
 640                         &b_numeric,&b_help_info, &text, &text_len, &duration);
 641 #endif
 642                 get_inkey.commandId = command_id;
 643                 get_inkey.keyType = key_type;
 644                 get_inkey.inputCharMode = input_character_mode;
 645                 get_inkey.bIsNumeric = (b_numeric ? 1 : 0);
 646                 get_inkey.bIsHelpInfoAvailable = (b_help_info ? 1 : 0);
 647                 memcpy(get_inkey.text.string, text, TAPI_SAT_DEF_TEXT_STRING_LEN_MAX+1);
 648                 g_free(text);
 649                 get_inkey.text.stringLen = text_len;
 650                 get_inkey.duration = duration;
 651
 652 #if defined(TIZEN_SUPPORT_SAT_ICON)
 653                 if(icon_id) {
 654                         unbox = g_variant_get_variant(icon_id);
 655                         g_variant_get(unbox, "a(biiiiiis)", &iter);
 656
 657                         while(g_variant_iter_loop(iter,"(biiiiiis)", &is_exist, &icon_quali, &icon_identifier, &width, &height, &ics, &icon_data_len, &icon_data)) {
 658                                 if(!is_exist)
 659                                         break;
 660                                 get_inkey.iconId.bIsPresent = is_exist;
 661                                 get_inkey.iconId.iconQualifier = icon_quali;
 662                                 get_inkey.iconId.iconIdentifier = icon_identifier;
 663                                 get_inkey.iconId.iconInfo.width = width;
 664                                 get_inkey.iconId.iconInfo.height = height;
 665                                 get_inkey.iconId.iconInfo.ics = ics;
 666                                 if(icon_data_len > 0) {
 667                                         get_inkey.iconId.iconInfo.iconDataLen = icon_data_len;
 668                                         memcpy(get_inkey.iconId.iconInfo.iconFile, icon_data, icon_data_len);
 669                                 }
 670                                 dbg("icon exist(%d), icon_quali: (%d), icon_id: (%d), width: (%d), height: (%d), ics: (%d), icon_data_len: (%d)", get_inkey.iconId.bIsPresent, get_inkey.iconId.iconQualifier, get_inkey.iconId.iconIdentifier, get_inkey.iconId.iconInfo.width,
 671                                         get_inkey.iconId.iconInfo.height, get_inkey.iconId.iconInfo.ics, get_inkey.iconId.iconInfo.iconDataLen);
 672                         }
 673                         g_variant_iter_free(iter);
 674                 }
 675 #endif
 676                 dbg("command id(%d)", get_inkey.commandId);
 677                 dbg("key type(%d)", get_inkey.keyType);
 678                 dbg("input character mode(%d)", get_inkey.inputCharMode);
 679                 dbg("numeric(%d)", get_inkey.bIsNumeric);
 680                 dbg("help info available(%d)", get_inkey.bIsHelpInfoAvailable);
 681                 dbg("text (%s)", get_inkey.text.string);
 682                 dbg("text length", get_inkey.text.stringLen);
 683                 dbg("duration", get_inkey.duration);
 684
 685                 CALLBACK_CALL(&get_inkey);
 686         }
 687         else if (!g_strcmp0(sig, "GetInput")) {
 688                 TelSatGetInputInd_t get_input;
 689
 690                 gint command_id, input_character_mode;
 691                 gint text_len, def_text_len, rsp_len_min, rsp_len_max;
 692                 gboolean b_numeric, b_help_info, b_echo_input;
 693                 gchar *text = NULL, *def_text = NULL;
 694 #if defined(TIZEN_SUPPORT_SAT_ICON)
 695                 GVariant *unbox = NULL;
 696                 gboolean is_exist;
 697                 gint icon_quali, icon_identifier, width, height, ics, icon_data_len;
 698                 gchar *icon_data = NULL;
 699                 GVariant *icon_id = NULL;
 700                 GVariantIter *iter;
 701 #endif
 702                 memset(&get_input, 0, sizeof(TelSatGetInputInd_t));
 703
 704 #if defined(TIZEN_SUPPORT_SAT_ICON)
 705                 g_variant_get(param, "(iibbbsiiisi@v)", &command_id, &input_character_mode, &b_numeric, &b_help_info, &b_echo_input,
 706                         &text, &text_len, &rsp_len_max, &rsp_len_min, &def_text, &def_text_len, &icon_id);
 707 #else
 708                 g_variant_get(param, "(iibbbsiiisi)", &command_id, &input_character_mode, &b_numeric, &b_help_info, &b_echo_input,
 709                         &text, &text_len, &rsp_len_max, &rsp_len_min, &def_text, &def_text_len);
 710 #endif
 711                 get_input.commandId = command_id;
 712                 get_input.inputCharMode = input_character_mode;
 713                 get_input.bIsNumeric = (b_numeric ? 1 : 0);
 714                 get_input.bIsHelpInfoAvailable = (b_help_info ? 1 : 0);
 715                 get_input.bIsEchoInput = (b_echo_input ? 1 : 0);
 716                 memcpy(get_input.text.string, text, TAPI_SAT_DEF_TEXT_STRING_LEN_MAX+1);
 717                 g_free(text);
 718                 get_input.text.stringLen = text_len;
 719                 get_input.respLen.max = rsp_len_max;
 720                 get_input.respLen.min = rsp_len_min;
 721                 memcpy(get_input.defaultText.string, def_text, TAPI_SAT_DEF_TEXT_STRING_LEN_MAX+1);
 722                 g_free(def_text);
 723                 get_input.defaultText.stringLen = def_text_len;
 724
 725 #if defined(TIZEN_SUPPORT_SAT_ICON)
 726                 if(icon_id) {
 727                         unbox = g_variant_get_variant(icon_id);
 728                         g_variant_get(unbox, "a(biiiiiis)", &iter);
 729
 730                         while(g_variant_iter_loop(iter,"(biiiiiis)", &is_exist, &icon_quali, &icon_identifier, &width, &height, &ics, &icon_data_len, &icon_data)) {
 731                                 if(!is_exist)
 732                                         break;
 733                                 get_input.iconId.bIsPresent = is_exist;
 734                                 get_input.iconId.iconQualifier = icon_quali;
 735                                 get_input.iconId.iconIdentifier = icon_identifier;
 736                                 get_input.iconId.iconInfo.width = width;
 737                                 get_input.iconId.iconInfo.height = height;
 738                                 get_input.iconId.iconInfo.ics = ics;
 739                                 if(icon_data_len > 0) {
 740                                         get_input.iconId.iconInfo.iconDataLen = icon_data_len;
 741                                         memcpy(get_input.iconId.iconInfo.iconFile, icon_data, icon_data_len);
 742                                 }
 743                                 dbg("icon exist(%d), icon_quali: (%d), icon_id: (%d), width: (%d), height: (%d), ics: (%d), icon_data_len: (%d)", get_input.iconId.bIsPresent, get_input.iconId.iconQualifier, get_input.iconId.iconIdentifier, get_input.iconId.iconInfo.width,
 744                                         get_input.iconId.iconInfo.height, get_input.iconId.iconInfo.ics, get_input.iconId.iconInfo.iconDataLen);
 745                         }
 746                         g_variant_iter_free(iter);
 747                 }
 748 #endif
 749                 dbg("command id(%d)", get_input.commandId);
 750                 dbg("input character mode(%d)", get_input.inputCharMode);
 751                 dbg("numeric(%d)", get_input.bIsNumeric);
 752                 dbg("help info avaiable(%d)", get_input.bIsHelpInfoAvailable);
 753                 dbg("echo input(%d)", get_input.bIsEchoInput);
 754                 dbg("text(%s)", get_input.text.string);
 755                 dbg("text length(%d)", get_input.text.stringLen);
 756                 dbg("response length max(%d)", get_input.respLen.max);
 757                 dbg("response length min(%d)", get_input.respLen.min);
 758                 dbg("default text(%s)", get_input.defaultText.string);
 759                 dbg("default text length(%d)", get_input.defaultText.stringLen);
 760
 761                 CALLBACK_CALL(&get_input);
 762         }
 763         else if (!g_strcmp0(sig, "SendSMS")) {
 764                 TelSatSendSmsIndSmsData_t send_sms;
 765
 766                 gint command_id, ton, npi, tpdu_type;
 767                 gboolean b_packing_required;
 768                 gint text_len, number_len, tpdu_data_len;
 769                 gchar* text = NULL, *dialling_number = NULL;
 770                 GVariant *tpdu_data;
 771
 772                 memset(&send_sms, 0, sizeof(TelSatSendSmsIndSmsData_t));
 773
 774                 g_variant_get(param, "(isibiisii@vi)", &command_id, &text, &text_len, &b_packing_required, &ton, &npi,
 775                                         &dialling_number, &number_len, &tpdu_type, &tpdu_data, &tpdu_data_len);
 776
 777                 send_sms.commandId = command_id;
 778                 send_sms.bIsPackingRequired = (b_packing_required ? 1 : 0);
 779
 780                 send_sms.address.ton = ton;
 781                 send_sms.address.npi = npi;
 782                 send_sms.address.diallingNumberLen = number_len;
 783                 memcpy(send_sms.address.diallingNumber, dialling_number, TAPI_SAT_DIALLING_NUMBER_LEN_MAX);
 784                 g_free(dialling_number);
 785                 g_free(text);
 786
 787                 send_sms.smsTpdu.tpduType = tpdu_type;
 788                 send_sms.smsTpdu.dataLen = tpdu_data_len;
 789
 790                 if(tpdu_data){
 791                         int send_sms_index = 0;
 792                         guchar data;
 793                         GVariantIter *iter = NULL;
 794                         GVariant *inner_gv = NULL;
 795
 796                         inner_gv = g_variant_get_variant(tpdu_data);
 797                         dbg("tpdu data exist type_format(%s)", g_variant_get_type_string(inner_gv));
 798
 799                         g_variant_get(inner_gv, "ay", &iter);
 800                         while( g_variant_iter_loop (iter, "y", &data)){
 801                                 dbg("index(%d) data(%c)", send_sms_index, data);
 802                                 send_sms.smsTpdu.data[send_sms_index] = data;
 803                                 send_sms_index++;
 804                         }
 805                         g_variant_iter_free(iter);
 806                         g_variant_unref(inner_gv);
 807                 }
 808
 809                 dbg("command id(%d)", send_sms.commandId);
 810                 dbg("packing required(%d)", send_sms.bIsPackingRequired);
 811                 dbg("address ton(%d)", send_sms.address.ton);
 812                 dbg("address npi(%d)", send_sms.address.npi);
 813                 dbg("address dialing number (%s)", send_sms.address.diallingNumber);
 814                 dbg("address number length (%d)", send_sms.address.diallingNumberLen);
 815                 dbg("tpdu type (%d)", send_sms.smsTpdu.tpduType);
 816                 dbg("tpdu length (%d)", send_sms.smsTpdu.dataLen);
 817
 818                 CALLBACK_CALL(&send_sms);
 819         }
 820         else if (!g_strcmp0(sig, "SetupEventList")) {
 821                 int g_index = 0;
 822                 gint event_cnt;
 823                 GVariant *evt_list;
 824                 TelSatEventListData_t event_list;
 825
 826                 memset(&event_list, 0, sizeof(TelSatEventListData_t));
 827
 828                 g_variant_get(param, "(i@v)", &event_cnt, &evt_list);
 829
 830                 if(evt_list){
 831                         guchar data;
 832                         GVariantIter *iter = NULL;
 833                         GVariant *inner_gv = NULL;
 834
 835                         inner_gv = g_variant_get_variant(evt_list);
 836                         dbg("event list exist type_format(%s)", g_variant_get_type_string(inner_gv));
 837
 838                         g_variant_get(inner_gv, "ai", &iter);
 839                         while( g_variant_iter_loop (iter, "i", &data)){
 840                                 dbg("g_index(%d) event(%d)", g_index, data);
 841                                 g_event_list[g_index] = data;
 842
 843                                 if(data == TAPI_EVENT_SAT_DW_TYPE_IDLE_SCREEN_AVAILABLE){
 844                                         event_list.bIsIdleScreenAvailable = 1;
 845                                 }
 846                                 else if(data == TAPI_EVENT_SAT_DW_TYPE_LANGUAGE_SELECTION){
 847                                         event_list.bIsLanguageSelection = 1;
 848                                 }
 849                                 else if(data == TAPI_EVENT_SAT_DW_TYPE_BROWSER_TERMINATION){
 850                                         event_list.bIsBrowserTermination = 1;
 851                                 }
 852                                 else if(data == TAPI_EVENT_SAT_DW_TYPE_DATA_AVAILABLE){
 853                                         event_list.bIsDataAvailable = 1;
 854                                 }
 855                                 else if(data == TAPI_EVENT_SAT_DW_TYPE_CHANNEL_STATUS){
 856                                         event_list.bIsChannelStatus = 1;
 857                                 }
 858
 859                                 g_index++;
 860                         }
 861                         //while end
 862                         g_variant_iter_free(iter);
 863                         g_variant_unref(inner_gv);
 864                 }
 865
 866                 dbg("event list cnt(%d)", event_cnt);
 867
 868                 CALLBACK_CALL(&event_list);
 869         }
 870         else if (!g_strcmp0(sig, "Refresh")) {
 871                 TelSatRefreshInd_t refresh_info;
 872
 873                 gint command_id = 0;
 874                 gint refresh_type =0;
 875                 gint file_cnt = 0;
 876                 GVariant *file_list = NULL;
 877
 878                 memset(&refresh_info, 0, sizeof(TelSatRefreshInd_t));
 879
 880                 g_variant_get(param, "(ii@v)", &command_id, &refresh_type, &file_list);
 881
 882                 refresh_info.commandId = command_id;
 883                 refresh_info.refreshMode = refresh_type;
 884
 885                 if(file_list){
 886                         int g_index = 0;
 887                         guchar data;
 888                         GVariantIter *iter = NULL;
 889                         GVariant *inner_gv = NULL;
 890
 891                         inner_gv = g_variant_get_variant(file_list);
 892                         dbg("file list exist type_format(%s)", g_variant_get_type_string(inner_gv));
 893
 894                         g_variant_get(inner_gv, "ai", &iter);
 895                         while( g_variant_iter_loop (iter, "i", &data)){
 896                                 dbg("g_index(%d) file id(%d)", g_index, data);
 897                                 refresh_info.fileId[g_index] = data;
 898                                 g_index++;
 899                         }
 900                         file_cnt = g_index;
 901
 902                         //while end
 903                         g_variant_iter_free(iter);
 904                         g_variant_unref(inner_gv);
 905                 }
 906                 refresh_info.fileCount = file_cnt;
 907
 908                 dbg("refresh event/file cnt(%d)", refresh_info.fileCount);
 909
 910                 CALLBACK_CALL(&refresh_info);
 911         }
 912         else if (!g_strcmp0(sig, "SendDtmf")) {
 913                 TelSatSendDtmfIndDtmfData_t send_dtmf;
 914
 915                 gint command_id = 0;
 916                 gint text_len = 0, dtmf_str_len = 0;
 917                 gchar *text = NULL;
 918                 gchar *dtmf_str = NULL;
 919
 920                 memset(&send_dtmf, 0, sizeof(TelSatSendDtmfIndDtmfData_t));
 921
 922                 g_variant_get(param, "(isisi)", &command_id, &text, &text_len, &dtmf_str, &dtmf_str_len);
 923
 924                 send_dtmf.commandId = command_id;
 925                 send_dtmf.bIsHiddenMode = 1;
 926
 927                 send_dtmf.dtmfString.stringLen = dtmf_str_len;
 928                 memcpy(send_dtmf.dtmfString.string, dtmf_str, TAPI_SAT_DEF_TEXT_STRING_LEN_MAX+1);
 929                 g_free(dtmf_str);
 930                 g_free(text);
 931
 932                 dbg("dtmf event command id(%d)", send_dtmf.commandId);
 933                 dbg("dtmf event dtmf(%s)", send_dtmf.dtmfString.string);
 934
 935                 CALLBACK_CALL(&send_dtmf);
 936         }
 937         else if (!g_strcmp0(sig, "EndProactiveSession")) {
 938                 int command_type = 0;
 939
 940                 g_variant_get(param, "(i)", &command_type);
 941                 dbg("end session evt : command type(%d)", command_type);
 942                 CALLBACK_CALL(&command_type);
 943         }
 944         else if (!g_strcmp0(sig, "CallControlResult")) {
 945                 TelSatCallCtrlIndData_t call_ctrl_result_ind;
 946                 gint call_ctrl_result = 0, disp_len = 0;
 947                 gint bc_repeat_indicator = 0, ton = 0x0F, npi=0X0F;
 948                 gchar *text = NULL, *call_num = NULL, *ss_string = NULL, *sub_addr = NULL, *ccp1 = NULL, *ccp2 = NULL;
 949
 950                 memset(&call_ctrl_result_ind, 0x00, sizeof(TelSatCallCtrlIndData_t));
 951
 952                 g_variant_get(param, "(isiisssssi)", &call_ctrl_result, &text, &ton, &npi, &call_num,
 953                         &ss_string, &sub_addr, &ccp1, &ccp2, &bc_repeat_indicator);
 954
 955                 call_ctrl_result_ind.callCtrlResult = call_ctrl_result;
 956                 disp_len = strlen(text); //alpha id
 957                 if(disp_len >1) {
 958                         call_ctrl_result_ind.dispData.stringLen = disp_len;
 959                         memcpy(&call_ctrl_result_ind.dispData.string, text, disp_len);
 960                         call_ctrl_result_ind.bIsUserInfoDisplayEnabled = 1;
 961                 }
 962                 g_free(text);
 963
 964                 if(strlen(call_num) > 1 && (g_strcmp0(call_num,"") != 0) ){
 965                         call_ctrl_result_ind.callCtrlCnfType = TAPI_SAT_CALL_TYPE_MO_VOICE;
 966                         call_ctrl_result_ind.u.callCtrlCnfCallData.address.stringLen = strlen(call_num);
 967                         memcpy(&call_ctrl_result_ind.u.callCtrlCnfCallData.address.string, call_num, strlen(call_num));
 968                         call_ctrl_result_ind.u.callCtrlCnfCallData.subAddress.stringLen = strlen(sub_addr);
 969                         memcpy(&call_ctrl_result_ind.u.callCtrlCnfCallData.subAddress.string, sub_addr, strlen(sub_addr));
 970                         call_ctrl_result_ind.u.callCtrlCnfCallData.ccp1.stringLen = strlen(ccp1);
 971                         memcpy(&call_ctrl_result_ind.u.callCtrlCnfCallData.ccp1.string, ccp1, strlen(ccp1));
 972                         call_ctrl_result_ind.u.callCtrlCnfCallData.ccp1.stringLen = strlen(ccp2);
 973                         memcpy(&call_ctrl_result_ind.u.callCtrlCnfCallData.ccp1.string, ccp2, strlen(ccp2));
 974                         call_ctrl_result_ind.u.callCtrlCnfCallData.bcRepeatIndicator = bc_repeat_indicator;
 975                 }//call number exist
 976                 else if( strlen(ss_string) > 1 && (g_strcmp0(ss_string,"") != 0) ){
 977                         call_ctrl_result_ind.callCtrlCnfType = TAPI_SAT_CALL_TYPE_SS;
 978                         call_ctrl_result_ind.u.callCtrlCnfSsData.ssString.stringLen = strlen(ss_string);
 979                         memcpy(&call_ctrl_result_ind.u.callCtrlCnfSsData.ssString.string, ss_string, strlen(ss_string));
 980                         call_ctrl_result_ind.u.callCtrlCnfSsData.subAddress.stringLen = strlen(sub_addr);
 981                         memcpy(&call_ctrl_result_ind.u.callCtrlCnfSsData.subAddress.string, sub_addr, strlen(sub_addr));
 982                         call_ctrl_result_ind.u.callCtrlCnfSsData.ccp1.stringLen = strlen(ccp1);
 983                         memcpy(&call_ctrl_result_ind.u.callCtrlCnfSsData.ccp1.string, ccp1, strlen(ccp1));
 984                         call_ctrl_result_ind.u.callCtrlCnfSsData.ccp1.stringLen = strlen(ccp2);
 985                         memcpy(&call_ctrl_result_ind.u.callCtrlCnfSsData.ccp1.string, ccp2, strlen(ccp2));
 986                         call_ctrl_result_ind.u.callCtrlCnfSsData.bcRepeatIndicator = bc_repeat_indicator;
 987                 }//ss string exist
 988                 else{
 989                         dbg("not matched call control");
 990                         goto EXIT;
 991                 }
 992
 993                 CALLBACK_CALL(&call_ctrl_result_ind);
 994
 995 EXIT:
 996                 g_free(call_num);
 997                 g_free(sub_addr);
 998                 g_free(ccp1);
 999                 g_free(ccp2);
1000                 g_free(ss_string);
1001         }
1002         else if (!g_strcmp0(sig, "MoSmControlResult")) {
1003                 TelSatMoSmCtrlIndData_t mo_sm_ctrl_result_ind;
1004                 gint call_ctrl_result = 0 ,disp_len = 0;
1005                 gint rp_dst_ton = 0x0F, rp_dst_npi = 0X0F, tp_dst_ton = 0x0F, tp_dst_npi = 0X0F;
1006                 gchar *text = NULL, *rp_dst_call_num = NULL, *tp_dst_call_num = NULL;
1007
1008                 memset(&mo_sm_ctrl_result_ind, 0x00, sizeof(TelSatMoSmCtrlIndData_t));
1009
1010                 g_variant_get(param, "(isiisiis)", &call_ctrl_result, &text,
1011                         &rp_dst_ton, &rp_dst_npi, &rp_dst_call_num, &tp_dst_ton, &tp_dst_npi, &tp_dst_call_num);
1012
1013                 mo_sm_ctrl_result_ind.moSmsCtrlResult= call_ctrl_result;
1014                 disp_len = strlen(text); //alpha id
1015                 if(disp_len >1) {
1016                         mo_sm_ctrl_result_ind.dispData.stringLen = disp_len;
1017                         memcpy(&mo_sm_ctrl_result_ind.dispData.string, text, disp_len);
1018                         mo_sm_ctrl_result_ind.bIsUserInfoDisplayEnabled = 1;
1019                 }
1020
1021                 if(strlen(rp_dst_call_num) > 1 && (g_strcmp0(rp_dst_call_num,"") != 0) ){
1022                         mo_sm_ctrl_result_ind.tpDestAddr.bIsDigitOnly = 1;
1023                         mo_sm_ctrl_result_ind.rpDestAddr.stringLen = strlen(rp_dst_call_num);
1024                         memcpy(&mo_sm_ctrl_result_ind.rpDestAddr.string, rp_dst_call_num, strlen(rp_dst_call_num));
1025                 }// rp dst call number exist
1026                 else if( strlen(tp_dst_call_num) > 1 && (g_strcmp0(tp_dst_call_num,"") != 0) ){
1027                         mo_sm_ctrl_result_ind.tpDestAddr.bIsDigitOnly = 1;
1028                         mo_sm_ctrl_result_ind.tpDestAddr.stringLen = strlen(tp_dst_call_num);
1029                         memcpy(&mo_sm_ctrl_result_ind.tpDestAddr.string, tp_dst_call_num, strlen(tp_dst_call_num));
1030                 }//tp dst call number exist
1031                 else{
1032                         dbg("Any destination address are not provided, use default one.");
1033                 }
1034                 g_free(text);
1035                 g_free(rp_dst_call_num);
1036                 g_free(tp_dst_call_num);
1037
1038                 CALLBACK_CALL(&mo_sm_ctrl_result_ind);
1039         }
1040         else {
1041                 dbg("not handled Sat noti[%s]", sig);
1042         }
1043 }
1044
1045 static void _process_sim_event(const gchar *sig, GVariant *param,
1046         TapiHandle *handle, char *noti_id, struct tapi_evt_cb *evt_cb_data)
1047 {
1048         TAPI_RETURN_IF_FAIL(evt_cb_data);
1049
1050         if (!g_strcmp0(sig, "Status")) {
1051                 int status = 0;
1052                 g_variant_get(param, "(i)", &status);
1053                 CALLBACK_CALL(&status);
1054         } else if (!g_strcmp0(sig, "Refreshed")) {
1055                 int type = 0;
1056                 g_variant_get(param, "(i)", &type);
1057                 CALLBACK_CALL(&type);
1058         } else {
1059                 dbg("not handled SIM noti[%s]",sig );
1060         }
1061 }
1062
1063 static void _process_pb_event(const gchar *sig, GVariant *param,
1064         TapiHandle *handle, char *noti_id, struct tapi_evt_cb *evt_cb_data)
1065 {
1066         TAPI_RETURN_IF_FAIL(evt_cb_data);
1067
1068         if (!g_strcmp0(sig, "Status")) {
1069                 TelSimPbStatus_t status;
1070                 g_variant_get(param, "(ibbbbbb)",
1071                         &status.init_completed,
1072                         &status.pb_list.b_fdn,
1073                         &status.pb_list.b_adn,
1074                         &status.pb_list.b_sdn,
1075                         &status.pb_list.b_3g,
1076                         &status.pb_list.b_aas,
1077                         &status.pb_list.b_gas);
1078
1079                 msg("(%s) init[%d] fdn[%d] adn[%d] sdn[%d] usim[%d] aas[%d] gas[%d]",
1080                         handle->cp_name, status.init_completed, status.pb_list.b_fdn,status.pb_list.b_adn,status.pb_list.b_sdn,status.pb_list.b_3g,status.pb_list.b_aas,status.pb_list.b_gas);
1081                 CALLBACK_CALL(&status);
1082         } else {
1083                 dbg("not handled Phonebook noti[%s]",sig );
1084         }
1085 }
1086
1087 static void _process_sap_event(const gchar *sig, GVariant *param,
1088         TapiHandle *handle, char *noti_id, struct tapi_evt_cb *evt_cb_data)
1089 {
1090         TAPI_RETURN_IF_FAIL(evt_cb_data);
1091
1092         if (!g_strcmp0(sig, "Status")) {
1093                 int noti = 0;
1094                 g_variant_get(param, "(i)", &noti);
1095                 CALLBACK_CALL(&noti);
1096         } else if (!g_strcmp0(sig, "Disconnect")) {
1097                 int disconnect = 0;
1098                 g_variant_get(param, "(i)", &disconnect);
1099                 CALLBACK_CALL(&disconnect);
1100         } else {
1101                 dbg("not handled SAP noti[%s]",sig );
1102         }
1103 }
1104
1105 static void _process_modem_event(const gchar *sig, GVariant *param,
1106         TapiHandle *handle, char *noti_id, struct tapi_evt_cb *evt_cb_data)
1107 {
1108         TAPI_RETURN_IF_FAIL(evt_cb_data);
1109
1110         if (!g_strcmp0(sig, "Power")) {
1111                 int noti = 0;
1112
1113                 g_variant_get(param, "(i)", &noti);
1114
1115                 CALLBACK_CALL(&noti);
1116         }
1117         else {
1118                 dbg("not handled Modem noti[%s]", sig);
1119         }
1120
1121         return;
1122 }
1123
1124 static void _process_ss_event(const gchar *sig, GVariant *param,
1125         TapiHandle *handle, char *noti_id, struct tapi_evt_cb *evt_cb_data)
1126 {
1127         GVariant *value = 0;
1128         GVariantIter *iter = 0;
1129         GVariantIter *iter_row = 0;
1130         const gchar *key = 0;
1131         int i = 0;
1132
1133         TAPI_RETURN_IF_FAIL(evt_cb_data);
1134
1135         if (!g_strcmp0(sig, "NotifyUSSD")) {
1136                 TelSsUssdMsgInfo_t noti;
1137                 char *str = NULL;
1138                 memset(&noti, 0, sizeof(TelSsUssdMsgInfo_t));
1139
1140                 g_variant_get(param, "(iiis)", &noti.Type, &noti.Dcs, &noti.Length, &str);
1141
1142                 if (str) {
1143                         g_strlcpy((char*)noti.szString, str, TAPI_SS_USSD_DATA_SIZE_MAX);
1144                         g_free(str);
1145                 }
1146
1147                 CALLBACK_CALL(&noti);
1148         }
1149         else if (!g_strcmp0(sig, "NotifySsInfo")) {
1150                 TelSsInfo_t noti;
1151                 memset(&noti, 0, sizeof(TelSsInfo_t));
1152
1153                 g_variant_get(param, "(ii)", &noti.Cause, &noti.SsType);
1154
1155                 CALLBACK_CALL(&noti);
1156         }
1157         else if (!g_strcmp0(sig, "ReleaseComplete")) {
1158                 TelSsRelCompMsgInfo_t noti;
1159                 GVariant *msg = 0;
1160                 int len = 0;
1161
1162                 memset ( &noti, 0, sizeof( TelSsRelCompMsgInfo_t ));
1163
1164                 g_variant_get(param, "(i@v)", &len, &msg);
1165
1166                 noti.RelCompMsgLen = (unsigned char)len;
1167
1168                 if(msg){
1169                         int count = 0;
1170                         guchar data;
1171                         GVariantIter *msg_iter = NULL;
1172                         GVariant *inner_gv = NULL;
1173
1174                         inner_gv = g_variant_get_variant(msg);
1175                         msg("[ check ] data exist type_format(%s)", g_variant_get_type_string(inner_gv));
1176
1177                         g_variant_get(inner_gv, "ay", &msg_iter);
1178                         while( g_variant_iter_loop (msg_iter, "y", &data)){
1179                                 msg("index(%d) data(%c)", count, data);
1180                                 noti.szRelCompMsg[count] = data;
1181                                 count++;
1182                         }
1183                         g_variant_iter_free(msg_iter);
1184                         g_variant_unref(inner_gv);
1185                 }
1186
1187                 CALLBACK_CALL(&noti);
1188
1189         } else if ( !g_strcmp0(sig, "NotifyForwarding") ) {
1190
1191                 TelSsForwardNoti_t noti;
1192                 memset(&noti, 0, sizeof(TelSsForwardNoti_t));
1193
1194                 g_variant_get (param, "(aa{sv})", &iter);
1195
1196                 noti.record_num = g_variant_iter_n_children(iter);
1197
1198                 if (TAPI_SS_RECORD_NUM_MAX < noti.record_num) {
1199                         noti.record_num = TAPI_SS_RECORD_NUM_MAX;
1200                 }
1201
1202                 while ( g_variant_iter_next(iter, "a{sv}", &iter_row ) && (i < noti.record_num)) {
1203                         while ( g_variant_iter_loop( iter_row, "{sv}", &key, &value ) ) {
1204
1205                                 if ( !g_strcmp0(key, "ss_class") ) {
1206                                         noti.record[i].Class = g_variant_get_int32(value);
1207                                 }
1208
1209                                 if ( !g_strcmp0(key, "ss_status") ) {
1210                                         noti.record[i].Status = g_variant_get_int32(value);
1211                                 }
1212
1213                                 if ( !g_strcmp0(key, "forwarding_mode") ) {
1214                                         noti.record[i].ForwardCondition = g_variant_get_int32(value);
1215                                 }
1216
1217                                 if ( !g_strcmp0(key, "number_present") ) {
1218                                         noti.record[i].bCallForwardingNumberPresent = g_variant_get_int32(value);
1219                                 }
1220
1221                                 if ( !g_strcmp0(key, "no_reply_time") ) {
1222                                         noti.record[i].NoReplyWaitTime = g_variant_get_int32(value);
1223                                 }
1224
1225                                 if ( !g_strcmp0(key, "type_of_number") ) {
1226                                         noti.record[i].Ton = g_variant_get_int32(value);
1227                                 }
1228
1229                                 if ( !g_strcmp0(key, "numbering_plan_identity") ) {
1230                                         noti.record[i].Npi = g_variant_get_int32(value);
1231                                 }
1232
1233                                 if ( !g_strcmp0(key, "forwarding_number") ) {
1234                                         strncpy((char *)noti.record[i].szCallForwardingNumber, g_variant_get_string(value, 0), TAPI_CALL_DIALDIGIT_LEN_MAX );
1235                                 }
1236
1237                         }
1238                         i++;
1239                         g_variant_iter_free(iter_row);
1240                 }
1241                 g_variant_iter_free(iter);
1242
1243                 CALLBACK_CALL(&noti);
1244
1245         } else if ( !g_strcmp0(sig, "NotifyWaiting") ) {
1246
1247                 TelSsWaitingNoti_t noti;
1248                 memset(&noti, '\0', sizeof(TelSsWaitingNoti_t));
1249
1250                 g_variant_get (param, "(aa{sv})", &iter);
1251
1252                 noti.record_num = g_variant_iter_n_children(iter);
1253
1254                 if (TAPI_SS_RECORD_NUM_MAX < noti.record_num) {
1255                         noti.record_num = TAPI_SS_RECORD_NUM_MAX;
1256                 }
1257
1258                 while ( g_variant_iter_next(iter, "a{sv}", &iter_row ) && (i < noti.record_num)) {
1259                         while ( g_variant_iter_loop( iter_row, "{sv}", &key, &value ) ) {
1260
1261                                 if ( !g_strcmp0(key, "ss_class") ) {
1262                                         noti.record[i].Class = g_variant_get_int32(value);
1263                                 }
1264
1265                                 if ( !g_strcmp0(key, "ss_status") ) {
1266                                         noti.record[i].Status = g_variant_get_int32(value);
1267                                 }
1268                         }
1269                         i++;
1270                         g_variant_iter_free(iter_row);
1271                 }
1272                 g_variant_iter_free(iter);
1273
1274                 CALLBACK_CALL(&noti);
1275
1276         } else if ( !g_strcmp0(sig, "NotifyBarring") ) {
1277
1278                 TelSsBarringNoti_t noti;
1279                 memset(&noti, '\0', sizeof(TelSsBarringNoti_t));
1280
1281                 g_variant_get (param, "(aa{sv})", &iter);
1282
1283                 noti.record_num = g_variant_iter_n_children(iter);
1284
1285                 if (TAPI_SS_RECORD_NUM_MAX < noti.record_num) {
1286                         noti.record_num = TAPI_SS_RECORD_NUM_MAX;
1287                 }
1288
1289                 while ( g_variant_iter_next(iter, "a{sv}", &iter_row ) ) {
1290                         while ( g_variant_iter_loop( iter_row, "{sv}", &key, &value ) && (i < noti.record_num)) {
1291
1292                                 if ( !g_strcmp0(key, "ss_class") ) {
1293                                         noti.record[i].Class = g_variant_get_int32(value);
1294                                 }
1295
1296                                 if ( !g_strcmp0(key, "ss_status") ) {
1297                                         noti.record[i].Status = g_variant_get_int32(value);
1298                                 }
1299
1300                                 if ( !g_strcmp0(key, "barring_mode") ) {
1301                                         noti.record[i].Flavour = g_variant_get_int32(value);
1302                                 }
1303
1304                         }
1305                         i++;
1306                         g_variant_iter_free(iter_row);
1307                 }
1308                 g_variant_iter_free(iter);
1309
1310                 CALLBACK_CALL(&noti);
1311
1312         } else {
1313                 dbg("not handled SS noti[%s]", sig);
1314         }
1315
1316         return;
1317 }
1318
1319 static void _process_gps_event(const gchar *sig, GVariant *param,
1320                 TapiHandle *handle, char *noti_id, struct tapi_evt_cb *evt_cb_data)
1321 {
1322         gboolean b_decode_data = FALSE;
1323         guchar *decoded_data = NULL;
1324
1325         TAPI_RETURN_IF_FAIL(evt_cb_data);
1326
1327         if (!g_strcmp0(sig, "AssistData")) {
1328                 b_decode_data = TRUE;
1329         }
1330         else if (!g_strcmp0(sig, "MeasurePosition")) {
1331                 b_decode_data = TRUE;
1332         }
1333         else if (!g_strcmp0(sig, "ResetAssistData")) {
1334                 /* noting to decode */
1335         }
1336         else if (!g_strcmp0(sig, "FrequencyAiding")) {
1337                 b_decode_data = TRUE;
1338         }
1339         else {
1340                 dbg("not handled Gps noti[%s]", sig);
1341         }
1342
1343         /* decoding data */
1344         if(b_decode_data) {
1345                 gchar *data = NULL;
1346                 gsize length;
1347                 dbg("[%s] decoding start", sig);
1348
1349                 g_variant_get(param, "(s)", &data);
1350                 decoded_data = g_base64_decode((const gchar *)data, &length);
1351                 if (decoded_data) {
1352                         CALLBACK_CALL(decoded_data);
1353                 }
1354                 g_free(data);
1355                 dbg("length=%d", length);
1356         }
1357
1358         if (decoded_data)
1359                 g_free(decoded_data);
1360 }
1361
1362 static void on_prop_callback(GDBusConnection *conn, const gchar *name, const gchar *path, const gchar *interface,
1363                 const gchar *sig, GVariant *param, gpointer user_data)
1364 {
1365         TapiHandle *handle = user_data;
1366         struct tapi_evt_cb *evt_cb_data = NULL;
1367         const gchar *interface_name_for_signal;
1368         GVariant *changed_properties = NULL;
1369         gchar **invalidated_properties = NULL;
1370         GVariantIter iter;
1371         gchar *key;
1372         GVariant *value;
1373         gchar *prev_value;
1374         char noti_id[256];
1375         char *data;
1376
1377         TAPI_RETURN_IF_FAIL(handle);
1378
1379         if (!g_variant_is_of_type (param, G_VARIANT_TYPE ("(sa{sv}as)"))) {
1380                 err("PropertiesChanged parameter type mismatch ('%s')", g_variant_get_type_string(param));
1381                 return;
1382         }
1383
1384         g_variant_get (param, "(&s@a{sv}^a&s)", &interface_name_for_signal,
1385                         &changed_properties, &invalidated_properties);
1386
1387         if (!changed_properties) {
1388                 err("Cannot get changed_properties");
1389                 goto fail;
1390         }
1391
1392         g_variant_iter_init (&iter, changed_properties);
1393         while (g_variant_iter_next (&iter, "{sv}", &key, &value)) {
1394
1395                 memset(noti_id, 0, 256);
1396                 snprintf (noti_id, 255, "%s:%s", interface_name_for_signal, key);
1397
1398                 evt_cb_data = g_hash_table_lookup (handle->evt_list, noti_id);
1399                 if (!evt_cb_data) {
1400                         g_variant_unref (value);
1401                         g_free((gchar *)key);
1402                         /* ignore un-registered property change callback */
1403                         continue;
1404
1405                 }
1406                 if (g_variant_is_of_type (value, G_VARIANT_TYPE_STRING )) {
1407                         data = g_try_malloc0 (g_variant_get_size (value) + 3);
1408                         if (!data) {
1409                                 warn ("g_try_malloc0 failed");
1410                                 g_variant_unref (value);
1411                                 g_free((gchar *)key);
1412                                 continue;
1413                         }
1414                         data[0] = 's';
1415                         data[1] = ':';
1416                         memcpy (data + 2, g_variant_get_data (value),
1417                                         g_variant_get_size (value));
1418                 }
1419                 else if (g_variant_is_of_type (value, G_VARIANT_TYPE_BOOLEAN )) {
1420                         data = g_strdup_printf ("b:%d",
1421                                         *(guchar *) g_variant_get_data (value));
1422                 }
1423                 else {
1424                         data = g_strdup_printf ("i:%d", *(int *) g_variant_get_data (value));
1425                 }
1426
1427                 prev_value = g_hash_table_lookup (handle->cache_property, noti_id);
1428                 if (prev_value) {
1429                         if (g_strcmp0 (data, prev_value) == 0) {
1430                                 g_free (data);
1431                                 g_variant_unref (value);
1432                                 g_free((gchar *)key);
1433                                 continue;
1434                         }
1435                 }
1436
1437                 msg("[%s] save prop: [%s] - [%s]", handle->cp_name, noti_id, data);
1438                 g_hash_table_replace (handle->cache_property, g_strdup(noti_id), data);
1439
1440                 {
1441                         int param_i = 0;
1442                         if (data[0] == 's') {
1443                                 CALLBACK_CALL((void * ) (data + 2));
1444                         }
1445                         else {
1446                                 param_i = atoi (data + 2);
1447                                 CALLBACK_CALL((void * )&param_i);
1448                         }
1449                 }
1450                 g_variant_unref (value);
1451                 g_free((gchar *)key);
1452         }
1453
1454         if (changed_properties != NULL )
1455                 g_variant_unref (changed_properties);
1456
1457 fail:
1458         if (invalidated_properties)
1459                 g_free (invalidated_properties);
1460 }
1461
1462 static void on_signal_callback(GDBusConnection *conn, const gchar *name, const gchar *path, const gchar *interface,
1463                 const gchar *sig, GVariant *param, gpointer user_data)
1464 {
1465         TapiHandle *handle = user_data;
1466         struct tapi_evt_cb *evt_cb_data = NULL;
1467         char *noti_id;
1468
1469         TAPI_RETURN_IF_FAIL(handle);
1470
1471         noti_id = g_strdup_printf("%s:%s", interface, sig);
1472
1473         evt_cb_data = g_hash_table_lookup(handle->evt_list, noti_id);
1474         if (!evt_cb_data) {
1475                 dbg("can't find noti_id(%s) callback info", noti_id);
1476                 g_free(noti_id);
1477                 return;
1478         }
1479
1480         if (!g_strcmp0(interface, DBUS_TELEPHONY_SMS_INTERFACE)) {
1481                 _process_sms_event(sig, param, handle, noti_id, evt_cb_data);
1482         }
1483         else if (!g_strcmp0(interface, DBUS_TELEPHONY_CALL_INTERFACE)) {
1484                 _process_call_event(sig, param, handle, noti_id, evt_cb_data);
1485         }
1486         else if (!g_strcmp0(interface, DBUS_TELEPHONY_SAT_INTERFACE)) {
1487                 _process_sat_event(sig, param, handle, noti_id, evt_cb_data);
1488         }
1489         else if (!g_strcmp0(interface, DBUS_TELEPHONY_SIM_INTERFACE)) {
1490                 _process_sim_event(sig, param, handle, noti_id, evt_cb_data);
1491         }
1492         else if (!g_strcmp0(interface, DBUS_TELEPHONY_PB_INTERFACE)) {
1493                 _process_pb_event(sig, param, handle, noti_id, evt_cb_data);
1494         }
1495         else if (!g_strcmp0(interface, DBUS_TELEPHONY_SAP_INTERFACE)) {
1496                 _process_sap_event(sig, param, handle, noti_id, evt_cb_data);
1497         }
1498         else if (!g_strcmp0(interface, DBUS_TELEPHONY_MODEM_INTERFACE)) {
1499                 _process_modem_event(sig, param, handle, noti_id, evt_cb_data);
1500         }
1501         else if (!g_strcmp0(interface, DBUS_TELEPHONY_SS_INTERFACE)) {
1502                 _process_ss_event(sig, param, handle, noti_id, evt_cb_data);
1503         }
1504         else if (!g_strcmp0(interface, DBUS_TELEPHONY_GPS_INTERFACE)) {
1505                 _process_gps_event(sig, param, handle, noti_id, evt_cb_data);
1506         }
1507         else if (!g_strcmp0(interface, DBUS_TELEPHONY_NETWORK_INTERFACE)) {
1508                 _process_network_event(sig, param, handle, noti_id, evt_cb_data);
1509         }
1510         else {
1511         }
1512         g_free(noti_id);
1513 }
1514
1515 EXPORT_API char** tel_get_cp_name_list(void)
1516 {
1517         GDBusObjectManager *obj_manager = NULL;
1518         gpointer d_conn = NULL;
1519         GList *objects = NULL;
1520         unsigned int cp_count = 0;
1521         char **cp_list = NULL;
1522         GList *iter = NULL;
1523         unsigned int index = 0;
1524         GError *error = NULL;
1525
1526         d_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
1527         if (!d_conn) {
1528                 err("Error creating dbus connection: %s\n", error->message);
1529                 g_error_free (error);
1530                 return NULL;
1531         }
1532
1533         obj_manager = g_dbus_object_manager_client_new_sync(d_conn,
1534                         G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE,
1535                         DBUS_TELEPHONY_SERVICE, /* "org.tizen.telephony" */
1536                         DBUS_TELEPHONY_DEFAULT_PATH, /* "/org/tizen/telephony" */
1537                         NULL, NULL, NULL,
1538                         NULL, &error);
1539         if (error) {
1540                 err("Error getting object manager client: %s", error->message);
1541                 g_error_free (error);
1542                 g_object_unref(d_conn);
1543                 return NULL;
1544         }
1545
1546         objects = g_dbus_object_manager_get_objects(obj_manager);
1547         cp_count = g_list_length(objects);
1548
1549         if (cp_count == 0) {
1550                 warn("cp count is 0");
1551                 goto OUT;
1552         }
1553         /* This will be freed by caller. +1 for NULL str at the end */
1554         cp_list = g_new0(char*, cp_count + 1);
1555         for (iter = objects, index = 0; iter != NULL; iter = iter->next, index++) {
1556                 gpointer *object = iter->data;
1557                 const gchar *object_path = g_dbus_object_get_object_path(G_DBUS_OBJECT(object));
1558                 if (object_path) {
1559                          /* CP list Will be freed up caller */
1560                         (cp_list)[index] = g_path_get_basename(object_path);
1561                         dbg("CP Name[%d/%d]: [%s]", index, cp_count-1, cp_list[index]);
1562                 }
1563         }
1564
1565 OUT:
1566         g_object_unref(d_conn);
1567         g_list_free_full(objects, g_object_unref);
1568         g_object_unref (obj_manager);
1569
1570         return cp_list;
1571 }
1572
1573 static char *get_property (TapiHandle *handle, const char *property,
1574                 const GVariantType *type)
1575 {
1576         char **dbus_info;
1577         GVariant *value = NULL;
1578         GVariant *value_container = NULL;
1579         GError *error = NULL;
1580         char *data = NULL;
1581
1582         dbus_info = g_strsplit (property, ":", 2);
1583         if (!dbus_info) {
1584                 dbg("invalid property");
1585                 return NULL ;
1586         }
1587
1588         if (!dbus_info[0] || !dbus_info[1]) {
1589                 dbg("invalid property");
1590                 goto OUT;
1591         }
1592
1593         value_container = g_dbus_connection_call_sync (handle->dbus_connection,
1594                         DBUS_TELEPHONY_SERVICE, handle->path,
1595                         "org.freedesktop.DBus.Properties", "Get",
1596                         g_variant_new ("(ss)", dbus_info[0], dbus_info[1]),
1597                         G_VARIANT_TYPE ("(v)"), G_DBUS_CALL_FLAGS_NONE,
1598                         TAPI_DEFAULT_TIMEOUT, handle->ca, &error);
1599
1600         if (error) {
1601                 if (error->code == G_DBUS_ERROR_ACCESS_DENIED) {
1602                         warn("Access Denied");
1603                         g_error_free(error);
1604                         return g_strdup("No access rights");
1605                 } else {
1606                         warn("dbus error = %d (%s)", error->code, error->message);
1607                         g_error_free (error);
1608                 }
1609         }
1610
1611         if (!value_container)
1612                 return NULL ;
1613
1614         g_variant_get (value_container, "(v)", &value);
1615         g_variant_unref (value_container);
1616
1617         if (g_variant_is_of_type (value, G_VARIANT_TYPE_STRING )) {
1618                 data = g_try_malloc0 (g_variant_get_size (value));
1619                 if (!data) {
1620                         warn ("calloc failed");
1621                         g_variant_unref (value);
1622                         goto OUT;
1623                 }
1624                 memcpy (data, g_variant_get_data (value), g_variant_get_size (value));
1625         }
1626         else if (g_variant_is_of_type (value, G_VARIANT_TYPE_BOOLEAN )) {
1627                 data = g_strdup_printf ("%d", *(guchar *) g_variant_get_data (value));
1628         }
1629         else {
1630                 data = g_strdup_printf ("%d", *(int *) g_variant_get_data (value));
1631         }
1632         msg("prop:[%s][%s] - [%s]", handle->cp_name, dbus_info[1], data);
1633
1634         g_variant_unref (value);
1635
1636 OUT:
1637         g_strfreev (dbus_info);
1638
1639         return data;
1640 }
1641
1642 EXPORT_API int tel_get_property_int (TapiHandle *handle,
1643                 const char *property, int *result)
1644 {
1645         char *data;
1646
1647         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_INPUT);
1648         TAPI_RET_ERR_NUM_IF_FAIL(property, TAPI_API_INVALID_INPUT);
1649         TAPI_RET_ERR_NUM_IF_FAIL(result, TAPI_API_INVALID_INPUT);
1650
1651         data = get_property (handle, property, G_VARIANT_TYPE_INT32);
1652         if (!data) {
1653                 return TAPI_API_OPERATION_FAILED;
1654         } else if (!g_strcmp0(data, "No access rights")) {
1655                 return TAPI_API_ACCESS_DENIED;
1656         }
1657
1658         *result = atoi(data);
1659
1660         g_free (data);
1661
1662         return TAPI_API_SUCCESS;
1663 }
1664
1665 EXPORT_API int tel_get_property_string(TapiHandle *handle, const char *property, char **result)
1666 {
1667         char *data;
1668
1669         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_INPUT);
1670         TAPI_RET_ERR_NUM_IF_FAIL(property, TAPI_API_INVALID_INPUT);
1671         TAPI_RET_ERR_NUM_IF_FAIL(result, TAPI_API_INVALID_INPUT);
1672
1673         data = get_property (handle, property, G_VARIANT_TYPE_STRING);
1674         if (!data) {
1675                 return TAPI_API_OPERATION_FAILED;
1676         } else if (!g_strcmp0(data, "No access rights")) {
1677                 return TAPI_API_ACCESS_DENIED;
1678         }
1679
1680         *result = data;
1681
1682         return TAPI_API_SUCCESS;
1683 }
1684
1685 EXPORT_API TapiHandle* tel_init(const char *cp_name)
1686 {
1687         GError *error = NULL;
1688         struct tapi_handle *handle;
1689
1690 #if !GLIB_CHECK_VERSION(2, 35, 0)
1691         g_type_init();
1692 #endif
1693
1694         handle = g_new0(struct tapi_handle, 1);
1695         if (!handle) {
1696                 return NULL;
1697         }
1698
1699         handle->dbus_connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
1700         if (!handle->dbus_connection) {
1701                 err("Error creating dbus connection: %s\n", error->message);
1702                 g_free(handle);
1703                 g_error_free (error);
1704                 return NULL;
1705         }
1706
1707         msg("tel_init: [%s]:[%s]:[%s]", g_dbus_connection_get_unique_name(
1708                                 handle->dbus_connection), program_invocation_name, cp_name?cp_name:"Null");
1709
1710         handle->ca = g_cancellable_new();
1711
1712         if (cp_name) {
1713                 handle->cp_name = g_strdup(cp_name);
1714         }
1715         else {
1716                 char **list = NULL;
1717                 int i = 0;
1718
1719                 list = tel_get_cp_name_list();
1720                 if (!list) {
1721                         g_cancellable_cancel(handle->ca);
1722                         g_object_unref(handle->ca);
1723                         g_object_unref(handle->dbus_connection);
1724                         g_free(handle);
1725                         return NULL;
1726                 }
1727
1728                 if (!list[0]) {
1729                         g_cancellable_cancel(handle->ca);
1730                         g_object_unref(handle->ca);
1731                         g_object_unref(handle->dbus_connection);
1732                         g_free(handle);
1733                         g_free (list);
1734                         return NULL;
1735                 }
1736
1737                 handle->cp_name = g_strdup(list[0]);
1738
1739                 /* Free the list of CP names */
1740                 while (list[i] != NULL) {
1741                         g_free(list[i++]);
1742                 }
1743
1744                 g_free (list);
1745         }
1746
1747         handle->evt_list = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
1748         handle->cache_property = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
1749
1750         handle->path = g_strdup_printf("%s/%s",
1751                         DBUS_TELEPHONY_DEFAULT_PATH, handle->cp_name);
1752
1753         return handle;
1754 }
1755
1756 static gboolean _unregister_noti(gpointer key, gpointer value, gpointer user_data)
1757 {
1758         struct tapi_evt_cb *evt_cb_data = value;
1759         TapiHandle *handle = user_data;
1760
1761         g_dbus_connection_signal_unsubscribe(handle->dbus_connection, evt_cb_data->evt_id);
1762
1763         return TRUE;
1764 }
1765
1766 EXPORT_API int tel_deinit(TapiHandle* handle)
1767 {
1768         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_INPUT);
1769
1770         if (handle->cp_name)
1771                 g_free(handle->cp_name);
1772
1773         if (handle->path)
1774                 g_free(handle->path);
1775
1776         g_dbus_connection_signal_unsubscribe(handle->dbus_connection, handle->prop_callback_evt_id);
1777         g_hash_table_foreach_remove(handle->evt_list, _unregister_noti, handle);
1778         g_hash_table_destroy(handle->evt_list);
1779         g_hash_table_destroy(handle->cache_property);
1780
1781         g_cancellable_cancel(handle->ca);
1782         g_object_unref(handle->ca);
1783
1784         g_object_unref (handle->dbus_connection);
1785
1786         memset(handle, 0, sizeof(struct tapi_handle));
1787         g_free(handle);
1788
1789         msg("tel_deinit done");
1790
1791         return TAPI_API_SUCCESS;
1792 }
1793
1794 EXPORT_API int tel_register_noti_event (TapiHandle *handle, const char *noti_id,
1795                 tapi_notification_cb callback, void *user_data)
1796 {
1797         gchar **dbus_str = NULL;
1798         gpointer tmp = NULL;
1799         struct tapi_evt_cb *evt_cb_data = NULL;
1800
1801         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_INPUT);
1802         TAPI_RET_ERR_NUM_IF_FAIL(handle->dbus_connection, TAPI_API_INVALID_INPUT);
1803         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_INPUT);
1804         TAPI_RET_ERR_NUM_IF_FAIL(noti_id, TAPI_API_INVALID_INPUT);
1805
1806         tmp = g_hash_table_lookup (handle->evt_list, noti_id);
1807         if (tmp != NULL ) {
1808                 dbg("noti_id(%s) is already registered", noti_id);
1809                 return TAPI_API_INVALID_INPUT;
1810         }
1811
1812         dbus_str = g_strsplit (noti_id, ":", 2);
1813         if (!dbus_str) {
1814                 dbg("invalid noti_id");
1815                 return TAPI_API_INVALID_INPUT;
1816         }
1817
1818         if (!dbus_str[0] || !dbus_str[1]) {
1819                 g_strfreev (dbus_str);
1820                 dbg("invalid noti_id");
1821                 return TAPI_API_INVALID_INPUT;
1822         }
1823
1824         evt_cb_data = g_new0(struct tapi_evt_cb, 1);
1825         evt_cb_data->cb_fn = callback;
1826         evt_cb_data->user_data = user_data;
1827
1828         dbg("[%s] signal (%s)", handle->cp_name, dbus_str[1]);
1829
1830         if (dbus_str[1][0] >= 'a' && dbus_str[1][0] <= 'z') {
1831                 /* Property change callback - only one time */
1832                 if (handle->prop_callback_evt_id == 0) {
1833                         handle->prop_callback_evt_id = g_dbus_connection_signal_subscribe (
1834                                         handle->dbus_connection, DBUS_TELEPHONY_SERVICE, /* Sender */
1835                                         "org.freedesktop.DBus.Properties", /* Interface */
1836                                         "PropertiesChanged", /* Member */
1837                                         handle->path, /* Object path */
1838                                         NULL, /* arg0 */
1839                                         G_DBUS_SIGNAL_FLAGS_NONE, on_prop_callback, handle, NULL );
1840                 }
1841         }
1842         else {
1843                 /* Signal callback */
1844                 evt_cb_data->evt_id = g_dbus_connection_signal_subscribe (
1845                                 handle->dbus_connection, DBUS_TELEPHONY_SERVICE, /* Sender */
1846                                 dbus_str[0], /* Interface */
1847                                 dbus_str[1], /* Member */
1848                                 handle->path, /* Object path */
1849                                 NULL, /* arg0 */
1850                                 G_DBUS_SIGNAL_FLAGS_NONE, on_signal_callback, handle, NULL );
1851
1852         }
1853
1854         g_hash_table_insert (handle->evt_list, g_strdup (noti_id), evt_cb_data);
1855
1856         g_strfreev (dbus_str);
1857
1858         return TAPI_API_SUCCESS;
1859 }
1860
1861 EXPORT_API int tel_deregister_noti_event (TapiHandle *handle,
1862                 const char *noti_id)
1863 {
1864         struct tapi_evt_cb *evt_cb_data = NULL;
1865         gboolean rv = FALSE;
1866
1867         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_INPUT);
1868         TAPI_RET_ERR_NUM_IF_FAIL(handle->dbus_connection, TAPI_API_INVALID_INPUT);
1869
1870         evt_cb_data = g_hash_table_lookup (handle->evt_list, noti_id);
1871         if (!evt_cb_data) {
1872                 dbg("event does not registered");
1873                 return TAPI_API_INVALID_INPUT;
1874         }
1875
1876         g_dbus_connection_signal_unsubscribe (handle->dbus_connection,
1877                         evt_cb_data->evt_id);
1878
1879         rv = g_hash_table_remove (handle->evt_list, noti_id);
1880         if (!rv) {
1881                 dbg("fail to deregister noti event(%s)", noti_id);
1882                 return TAPI_API_OPERATION_FAILED;
1883         }
1884
1885         return TAPI_API_SUCCESS;
1886 }
1887 /*      EOF     */