wearable/src/tapi_common.c

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