src/tapi_network.c

   1 /*
   2  * libslp-tapi
   3  *
   4  * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Ja-young Gu <jygu@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24
  25 #include "tapi_common.h"
  26 #include "TapiUtility.h"
  27 #include "TelNetwork.h"
  28
  29 #include "common.h"
  30 #include "tapi_log.h"
  31 #include "ITapiNetwork.h"
  32
  33 static int _convert_systemtype_to_act(int type)
  34 {
  35         switch (type) {
  36         case TAPI_NETWORK_SYSTEM_GSM:
  37                 return 0x1;
  38
  39         case TAPI_NETWORK_SYSTEM_GPRS:
  40                 return 0x2;
  41
  42         case TAPI_NETWORK_SYSTEM_EGPRS:
  43                 return 0x3;
  44
  45         case TAPI_NETWORK_SYSTEM_PCS1900:
  46                 break;
  47
  48         case TAPI_NETWORK_SYSTEM_UMTS:
  49                 return 0x4;
  50
  51         case TAPI_NETWORK_SYSTEM_GSM_AND_UMTS:
  52                 return 0x5;
  53
  54         case TAPI_NETWORK_SYSTEM_IS95A:
  55                 return 0x11;
  56
  57         case TAPI_NETWORK_SYSTEM_IS95B:
  58                 return 0x12;
  59
  60         case TAPI_NETWORK_SYSTEM_CDMA_1X:
  61                 return 0x13;
  62
  63         case TAPI_NETWORK_SYSTEM_EVDO_REV_0:
  64                 return 0x14;
  65
  66         case TAPI_NETWORK_SYSTEM_1X_EVDO_REV_0_HYBRID:
  67                 return 0x15;
  68
  69         case TAPI_NETWORK_SYSTEM_EVDO_REV_A:
  70                 return 0x16;
  71
  72         case TAPI_NETWORK_SYSTEM_1X_EVDO_REV_A_HYBRID:
  73                 return 0x17;
  74
  75         case TAPI_NETWORK_SYSTEM_EVDO_REV_B:
  76                 return 0x18;
  77
  78         case TAPI_NETWORK_SYSTEM_1X_EVDO_REV_B_HYBRID:
  79                 return 0x19;
  80
  81         case TAPI_NETWORK_SYSTEM_EVDV:
  82                 return 0x1A;
  83
  84         case TAPI_NETWORK_SYSTEM_EHRPD:
  85                 return 0x1B;
  86
  87         case TAPI_NETWORK_SYSTEM_LTE:
  88                 return 0x21;
  89
  90         default:
  91                 break;
  92         }
  93
  94         return 0xFF;
  95 }
  96
  97 static int _convert_act_to_systemtype(int act)
  98 {
  99         switch (act) {
 100         case 0x1:
 101                 return TAPI_NETWORK_SYSTEM_GSM;
 102
 103         case 0x2:
 104                 return TAPI_NETWORK_SYSTEM_GPRS;
 105
 106         case 0x3:
 107                 return TAPI_NETWORK_SYSTEM_EGPRS;
 108
 109         case 0x4:
 110                 return TAPI_NETWORK_SYSTEM_UMTS;
 111
 112         case 0x5:
 113                 return TAPI_NETWORK_SYSTEM_GSM_AND_UMTS;
 114
 115         case 0x11:
 116                 return TAPI_NETWORK_SYSTEM_IS95A;
 117
 118         case 0x12:
 119                 return TAPI_NETWORK_SYSTEM_IS95B;
 120
 121         case 0x13:
 122                 return TAPI_NETWORK_SYSTEM_CDMA_1X;
 123
 124         case 0x14:
 125                 return TAPI_NETWORK_SYSTEM_EVDO_REV_0;
 126
 127         case 0x15:
 128                 return TAPI_NETWORK_SYSTEM_1X_EVDO_REV_0_HYBRID;
 129
 130         case 0x16:
 131                 return TAPI_NETWORK_SYSTEM_EVDO_REV_A;
 132
 133         case 0x17:
 134                 return TAPI_NETWORK_SYSTEM_1X_EVDO_REV_A_HYBRID;
 135
 136         case 0x18:
 137                 return TAPI_NETWORK_SYSTEM_EVDO_REV_B;
 138
 139         case 0x19:
 140                 return TAPI_NETWORK_SYSTEM_1X_EVDO_REV_B_HYBRID;
 141
 142         case 0x1A:
 143                 return TAPI_NETWORK_SYSTEM_EVDV;
 144
 145         case 0x1B:
 146                 return TAPI_NETWORK_SYSTEM_EHRPD;
 147
 148         case 0x21:
 149                 return TAPI_NETWORK_SYSTEM_LTE;
 150
 151         default:
 152                 break;
 153         }
 154
 155         return TAPI_NETWORK_SYSTEM_NO_SRV;
 156 }
 157
 158 static void on_signal_registration_status(TapiHandle *handle, GVariant *param,
 159         char *noti_id, struct tapi_evt_cb *evt_cb_data)
 160 {
 161         TelNetworkRegistrationStatus_t noti;
 162
 163         g_variant_get(param, "(iiib)", &noti.cs, &noti.ps, &noti.type, &noti.is_roaming);
 164
 165         TAPI_INVOKE_NOTI_CALLBACK(&noti);
 166 }
 167
 168 static void on_signal_strength(TapiHandle *handle, GVariant *param,
 169                 char *noti_id, struct tapi_evt_cb *evt_cb_data)
 170 {
 171         struct tel_noti_network_signal_strength noti;
 172
 173         g_variant_get(param, "(i)", &noti.dbm);
 174
 175         TAPI_INVOKE_NOTI_CALLBACK(&noti);
 176 }
 177
 178 static void on_signal_cell_info(TapiHandle *handle, GVariant *param,
 179         char *noti_id, struct tapi_evt_cb *evt_cb_data)
 180 {
 181         struct tel_noti_network_cell_info noti;
 182
 183         memset(&noti, 0, sizeof(struct tel_noti_network_cell_info));
 184         g_variant_get(param, "(ii)", &noti.lac, &noti.cell_id);
 185
 186         TAPI_INVOKE_NOTI_CALLBACK(&noti);
 187 }
 188
 189 static void on_signal_change(TapiHandle *handle, GVariant *param,
 190         char *noti_id, struct tapi_evt_cb *evt_cb_data)
 191 {
 192         struct tel_noti_network_change noti;
 193         char *plmn = NULL;
 194         int act;
 195         memset(&noti, 0, sizeof(struct tel_noti_network_change));
 196
 197         g_variant_get(param, "(is)", &act, &plmn);
 198
 199         noti.act = _convert_act_to_systemtype(act);
 200
 201         if (plmn) {
 202                 snprintf(noti.plmn, 7, "%s", plmn);
 203                 g_free(plmn);
 204         }
 205
 206         TAPI_INVOKE_NOTI_CALLBACK(&noti);
 207 }
 208
 209 static void on_signal_time_info(TapiHandle *handle, GVariant *param,
 210         char *noti_id, struct tapi_evt_cb *evt_cb_data)
 211 {
 212         struct tel_noti_network_time_info noti;
 213         char *plmn = NULL;
 214
 215         memset(&noti, 0, sizeof(struct tel_noti_network_time_info));
 216         g_variant_get(param, "(iiiiiiiiibs)", &noti.year, &noti.month, &noti.day,
 217                         &noti.hour, &noti.minute, &noti.second,
 218                         &noti.wday, &noti.gmtoff, &noti.dstoff, &noti.isdst,
 219                         &plmn);
 220
 221         if (plmn) {
 222                 snprintf(noti.plmn, 7, "%s", plmn);
 223                 g_free(plmn);
 224         }
 225
 226         TAPI_INVOKE_NOTI_CALLBACK(&noti);
 227 }
 228
 229 static void on_signal_identity(TapiHandle *handle, GVariant *param,
 230         char *noti_id, struct tapi_evt_cb *evt_cb_data)
 231 {
 232         struct tel_noti_network_identity noti;
 233         char *plmn = NULL, *s_name = NULL, *f_name = NULL;
 234
 235         memset(&noti, 0, sizeof(struct tel_noti_network_identity));
 236
 237         g_variant_get(param, "(sss)", &plmn, &s_name, &f_name);
 238
 239         if (plmn) {
 240                 snprintf(noti.plmn, 7, "%s", plmn);
 241                 g_free(plmn);
 242         }
 243         if (s_name) {
 244                 snprintf(noti.short_name, 17, "%s", s_name);
 245                 g_free(s_name);
 246         }
 247         if (f_name) {
 248                 snprintf(noti.full_name, 33, "%s", f_name);
 249                 g_free(f_name);
 250         }
 251
 252         TAPI_INVOKE_NOTI_CALLBACK(&noti);
 253 }
 254
 255 static void on_emergency_callback_mode(TapiHandle *handle, GVariant *param,
 256         char *noti_id, struct tapi_evt_cb *evt_cb_data)
 257 {
 258         struct tel_noti_network_emergency_callback_mode noti;
 259
 260         memset(&noti, 0, sizeof(struct tel_noti_network_emergency_callback_mode));
 261
 262         g_variant_get(param, "(i)", &noti.mode);
 263
 264         TAPI_INVOKE_NOTI_CALLBACK(&noti);
 265 }
 266
 267 static void on_signal_default_data_subscription(TapiHandle *handle, GVariant *param,
 268         char *noti_id, struct tapi_evt_cb *evt_cb_data)
 269 {
 270         struct tel_noti_network_default_data_subs noti;
 271
 272         memset(&noti, 0, sizeof(struct tel_noti_network_default_data_subs));
 273
 274         g_variant_get(param, "(i)", &noti.default_subs);
 275
 276         TAPI_INVOKE_NOTI_CALLBACK(&noti);
 277 }
 278
 279 static void on_signal_default_subscription(TapiHandle *handle, GVariant *param,
 280         char *noti_id, struct tapi_evt_cb *evt_cb_data)
 281 {
 282         struct tel_noti_network_default_subs noti;
 283
 284         memset(&noti, 0, sizeof(struct tel_noti_network_default_subs));
 285
 286         g_variant_get(param, "(i)", &noti.default_subs);
 287
 288         TAPI_INVOKE_NOTI_CALLBACK(&noti);
 289 }
 290
 291 static void on_signal_cell_id(TapiHandle *handle, GVariant *param,
 292         char *noti_id, struct tapi_evt_cb *evt_cb_data)
 293 {
 294         int cell_id;
 295         g_variant_get(param, "(i)", &cell_id);
 296         TAPI_INVOKE_NOTI_CALLBACK(&cell_id);
 297 }
 298
 299 static void on_signal_lac(TapiHandle *handle, GVariant *param,
 300         char *noti_id, struct tapi_evt_cb *evt_cb_data)
 301 {
 302         int lac;
 303         g_variant_get(param, "(i)", &lac);
 304         TAPI_INVOKE_NOTI_CALLBACK(&lac);
 305 }
 306
 307 static void on_signal_tac(TapiHandle *handle, GVariant *param,
 308         char *noti_id, struct tapi_evt_cb *evt_cb_data)
 309 {
 310         int tac;
 311         g_variant_get(param, "(i)", &tac);
 312         TAPI_INVOKE_NOTI_CALLBACK(&tac);
 313 }
 314
 315 static void on_signal_system_id(TapiHandle *handle, GVariant *param,
 316         char *noti_id, struct tapi_evt_cb *evt_cb_data)
 317 {
 318         int system_id;
 319         g_variant_get(param, "(i)", &system_id);
 320         TAPI_INVOKE_NOTI_CALLBACK(&system_id);
 321 }
 322
 323 static void on_signal_network_id(TapiHandle *handle, GVariant *param,
 324         char *noti_id, struct tapi_evt_cb *evt_cb_data)
 325 {
 326         int network_id;
 327         g_variant_get(param, "(i)", &network_id);
 328         TAPI_INVOKE_NOTI_CALLBACK(&network_id);
 329 }
 330
 331 static void on_signal_bs_id(TapiHandle *handle, GVariant *param,
 332         char *noti_id, struct tapi_evt_cb *evt_cb_data)
 333 {
 334         int bs_id;
 335         g_variant_get(param, "(i)", &bs_id);
 336         TAPI_INVOKE_NOTI_CALLBACK(&bs_id);
 337 }
 338
 339 static void on_signal_bs_latitude(TapiHandle *handle, GVariant *param,
 340         char *noti_id, struct tapi_evt_cb *evt_cb_data)
 341 {
 342         int bs_latitude;
 343         g_variant_get(param, "(i)", &bs_latitude);
 344         TAPI_INVOKE_NOTI_CALLBACK(&bs_latitude);
 345 }
 346
 347 static void on_signal_bs_longitude(TapiHandle *handle, GVariant *param,
 348         char *noti_id, struct tapi_evt_cb *evt_cb_data)
 349 {
 350         int bs_longitude;
 351         g_variant_get(param, "(i)", &bs_longitude);
 352         TAPI_INVOKE_NOTI_CALLBACK(&bs_longitude);
 353 }
 354
 355 static struct signal_map signals[] = {
 356         { "RegistrationStatus", on_signal_registration_status },
 357         { "SignalStrength", on_signal_strength },
 358         { "CellInfo", on_signal_cell_info },
 359         { "Change", on_signal_change },
 360         { "TimeInfo", on_signal_time_info },
 361         { "Identity", on_signal_identity },
 362         { "EmergencyCallbackMode", on_emergency_callback_mode },
 363         { "DefaultDataSubscription", on_signal_default_data_subscription },
 364         { "DefaultSubscription", on_signal_default_subscription },
 365         { "CellId", on_signal_cell_id },
 366         { "Lac", on_signal_lac },
 367         { "Tac", on_signal_tac },
 368         { "SystemId", on_signal_system_id },
 369         { "NetworkId", on_signal_network_id },
 370         { "BsId", on_signal_bs_id },
 371         { "BsLatitude", on_signal_bs_latitude },
 372         { "BsLongitude", on_signal_bs_longitude },
 373 };
 374
 375 void _process_network_event(const gchar *sig, GVariant *param,
 376         TapiHandle *handle, char *noti_id, struct tapi_evt_cb *evt_cb_data)
 377 {
 378         unsigned int i;
 379         TAPI_RETURN_IF_FAIL(evt_cb_data);
 380
 381         for (i = 0; i < sizeof(signals) / sizeof(struct signal_map); i++) {
 382                 dbg("Received (%s)(%s) signal from telephony", handle->cp_name, sig);
 383                 if (!g_strcmp0(sig, signals[i].signal_name)) {
 384                         signals[i].callback(handle, param, noti_id, evt_cb_data);
 385                         return;
 386                 }
 387         }
 388
 389         dbg("not handled NETWORK noti[%s]", sig);
 390 }
 391
 392 static gboolean _check_plmn(const char *plmn)
 393 {
 394         unsigned int plmn_len = 0;
 395
 396         if (plmn == NULL) {
 397                 err("PLMN is NULL");
 398                 return FALSE;
 399         }
 400
 401         plmn_len = strlen(plmn);
 402         if (plmn_len < 5 || plmn_len > 6) {
 403                 err("PLMN length(%d) is invalid", plmn_len);
 404                 return FALSE;
 405         }
 406
 407         return TRUE;
 408 }
 409
 410 static gboolean _check_operation(TelNetworkPreferredPlmnOp_t operation)
 411 {
 412         switch (operation) {
 413         case TAPI_NETWORK_PREF_PLMN_ADD:
 414         case TAPI_NETWORK_PREF_PLMN_EDIT:
 415         case TAPI_NETWORK_PREF_PLMN_DELETE:
 416                 return TRUE;
 417         default:
 418                 /*Do Nothing*/
 419                 err("Default Case executed. Unknown PLMN Op");
 420                 break;
 421         }
 422         err("operation %d is not supported", operation);
 423         return FALSE;
 424 }
 425
 426 static gboolean _check_network_mode(int mode)
 427 {
 428         if (mode == TAPI_NETWORK_MODE_AUTO) {
 429                 return TRUE;
 430         } else {
 431                 if (mode & TAPI_NETWORK_MODE_GSM)
 432                         mode &= ~TAPI_NETWORK_MODE_GSM;
 433
 434                 if (mode & TAPI_NETWORK_MODE_WCDMA)
 435                         mode &= ~TAPI_NETWORK_MODE_WCDMA;
 436
 437                 if (mode & TAPI_NETWORK_MODE_1XRTT)
 438                         mode &= ~TAPI_NETWORK_MODE_1XRTT;
 439
 440                 if (mode & TAPI_NETWORK_MODE_LTE)
 441                         mode &= ~TAPI_NETWORK_MODE_LTE;
 442
 443                 if (mode & TAPI_NETWORK_MODE_EVDO)
 444                         mode &= ~TAPI_NETWORK_MODE_EVDO;
 445
 446                 if (mode == 0)
 447                         return TRUE;
 448         }
 449
 450         err("mode %d is not supported", mode);
 451         return FALSE;
 452 }
 453
 454 static gboolean _check_emergency_callback_mode(TelNetworkEmergencyCallbackMode_t mode)
 455 {
 456         switch (mode) {
 457         case TAPI_NETWORK_EMERGENCY_CALLBACK_MODE_ENTER:
 458         case TAPI_NETWORK_EMERGENCY_CALLBACK_MODE_EXIT:
 459                 return TRUE;
 460
 461         default:
 462                 /*Do Nothing*/
 463                 err("Default Case executed. Unknown Emergency callback mode");
 464                 break;
 465         }
 466         err("emergency callback mode %d is not supported", mode);
 467         return FALSE;
 468 }
 469
 470 static gboolean _check_roaming_preference(TelNetworkPrefNetType_t roam_pref)
 471 {
 472         switch (roam_pref) {
 473         case TAPI_NETWORK_PREF_NET_TYPE_HOME_ONLY:
 474         case TAPI_NETWORK_PREF_NET_TYPE_AFFILIATED:
 475         case TAPI_NETWORK_PREF_NET_TYPE_AUTOMATIC:
 476         case TAPI_NETWORK_PREF_NET_TYPE_AUTOMATIC_A:
 477         case TAPI_NETWORK_PREF_NET_TYPE_AUTOMATIC_B:
 478         case TAPI_NETWORK_PREF_NET_TYPE_ROAM_DOMESTIC:
 479         case TAPI_NETWORK_PREF_NET_TYPE_ROAM_INTERNATIONAL:
 480         case TAPI_NETWORK_PREF_NET_TYPE_ROAM_DUAL:
 481         case TAPI_NETWORK_PREF_NET_TYPE_BLANK:
 482                 return TRUE;
 483
 484         default:
 485                 /*Do Nothing*/
 486                 err("Default Case executed. Unknown roaming preference");
 487                 break;
 488         }
 489
 490         err("roam_pref %d is not supported", roam_pref);
 491         return FALSE;
 492 }
 493
 494 static void on_response_search_network(GObject *source_object,
 495                 GAsyncResult *res, gpointer user_data)
 496 {
 497         GError *error = NULL;
 498         struct tapi_resp_data *evt_cb_data = user_data;
 499         int result = -1;
 500         int i;
 501
 502         TelNetworkPlmnList_t list;
 503
 504         GVariant *dbus_result = NULL;
 505         GVariant *value = NULL;
 506         GVariantIter *iter = NULL;
 507         GVariantIter *iter_row = NULL;
 508         const gchar *key = NULL;
 509
 510         memset(&list, 0, sizeof(TelNetworkPlmnList_t));
 511
 512         dbus_result = g_dbus_connection_call_finish(G_DBUS_CONNECTION(source_object), res, &error);
 513         TAPI_RESP_CHECK_ERROR(error, evt_cb_data);
 514
 515         g_variant_get(dbus_result, "(aa{sv}i)", &iter, &result);
 516
 517         list.networks_count = g_variant_iter_n_children(iter);
 518
 519         i = 0;
 520         while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
 521                 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
 522                         if (!g_strcmp0(key, "plmn")) {
 523                                 strncpy(list.network_list[i].plmn, g_variant_get_string(value, NULL), TAPI_NETWORK_PLMN_LEN_MAX);
 524                                 list.network_list[i].plmn_id = atoi(g_variant_get_string(value, NULL));
 525                         } else if (!g_strcmp0(key, "act")) {
 526                                 list.network_list[i].access_technology = _convert_act_to_systemtype(g_variant_get_int32(value));
 527                         } else if (!g_strcmp0(key, "type")) {
 528                                 list.network_list[i].type_of_plmn = g_variant_get_int32(value);
 529                         } else if (!g_strcmp0(key, "name")) {
 530                                 strncpy(list.network_list[i].network_name, g_variant_get_string(value, NULL), 40);
 531                         }
 532                 }
 533                 i++;
 534                 g_variant_iter_free(iter_row);
 535         }
 536         g_variant_iter_free(iter);
 537
 538         TAPI_INVOKE_RESP_CALLBACK(evt_cb_data, result, &list);
 539
 540         g_free(evt_cb_data);
 541         g_variant_unref(dbus_result);
 542 }
 543
 544 static void on_response_get_network_selection_mode(GObject *source_object,
 545         GAsyncResult *res, gpointer user_data)
 546 {
 547         GError *error = NULL;
 548         struct tapi_resp_data *evt_cb_data = user_data;
 549         int result = -1;
 550
 551         GVariant *dbus_result;
 552         int mode = 0;
 553
 554         dbus_result = g_dbus_connection_call_finish(G_DBUS_CONNECTION(source_object), res, &error);
 555         TAPI_RESP_CHECK_ERROR(error, evt_cb_data);
 556
 557         g_variant_get(dbus_result, "(ii)", &mode, &result);
 558
 559         TAPI_INVOKE_RESP_CALLBACK(evt_cb_data, result, &mode);
 560
 561         g_free(evt_cb_data);
 562         g_variant_unref(dbus_result);
 563 }
 564
 565 static void on_response_default_set(GObject *source_object, GAsyncResult *res,
 566                 gpointer user_data)
 567 {
 568         GError *error = NULL;
 569         struct tapi_resp_data *evt_cb_data = user_data;
 570         int result = -1;
 571
 572         GVariant *dbus_result;
 573
 574         dbus_result = g_dbus_connection_call_finish(G_DBUS_CONNECTION(source_object), res, &error);
 575         TAPI_RESP_CHECK_ERROR(error, evt_cb_data);
 576
 577         g_variant_get(dbus_result, "(i)", &result);
 578
 579         TAPI_INVOKE_RESP_CALLBACK(evt_cb_data, result, NULL);
 580
 581         g_free(evt_cb_data);
 582         g_variant_unref(dbus_result);
 583 }
 584
 585 static void on_response_get_network_preferred_plmn(GObject *source_object,
 586                 GAsyncResult *res, gpointer user_data)
 587 {
 588         GError *error = NULL;
 589         struct tapi_resp_data *evt_cb_data = user_data;
 590         int result = -1;
 591         int i;
 592
 593         TelNetworkPreferredPlmnList_t list;
 594
 595         GVariant *dbus_result = NULL;
 596         GVariant *value = NULL;
 597         GVariantIter *iter = NULL;
 598         GVariantIter *iter_row = NULL;
 599         const gchar *key = NULL;
 600
 601         memset(&list, 0, sizeof(TelNetworkPreferredPlmnList_t));
 602
 603         dbus_result = g_dbus_connection_call_finish(G_DBUS_CONNECTION(source_object), res, &error);
 604         TAPI_RESP_CHECK_ERROR(error, evt_cb_data);
 605
 606         g_variant_get(dbus_result, "(aa{sv}i)", &iter, &result);
 607
 608         list.NumOfPrefPlmns = g_variant_iter_n_children(iter);
 609
 610         if (list.NumOfPrefPlmns == 0) {
 611                 dbg("num_of_.. = 0");
 612                 if (evt_cb_data->cb_fn)
 613                         evt_cb_data->cb_fn(evt_cb_data->handle, result, &list, evt_cb_data->user_data);
 614
 615                 g_free(evt_cb_data);
 616                 return;
 617         }
 618
 619         i = 0;
 620         while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
 621                 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
 622                         if (!g_strcmp0(key, "plmn"))
 623                                 strncpy(list.PrefPlmnRecord[i].Plmn, g_variant_get_string(value, NULL), 6);
 624                         else if (!g_strcmp0(key, "act"))
 625                                 list.PrefPlmnRecord[i].SystemType = _convert_act_to_systemtype(g_variant_get_int32(value));
 626                         else if (!g_strcmp0(key, "index"))
 627                                 list.PrefPlmnRecord[i].Index = g_variant_get_int32(value);
 628                         else if (!g_strcmp0(key, "name"))
 629                                 strncpy(list.PrefPlmnRecord[i].network_name, g_variant_get_string(value, NULL), 40);
 630                 }
 631                 i++;
 632                 g_variant_iter_free(iter_row);
 633         }
 634         g_variant_iter_free(iter);
 635
 636         TAPI_INVOKE_RESP_CALLBACK(evt_cb_data, result, &list);
 637
 638         g_free(evt_cb_data);
 639         g_variant_unref(dbus_result);
 640 }
 641
 642 static void on_response_get_network_mode(GObject *source_object,
 643                 GAsyncResult *res, gpointer user_data)
 644 {
 645         GError *error = NULL;
 646         struct tapi_resp_data *evt_cb_data = user_data;
 647         int result = -1;
 648
 649         GVariant *dbus_result;
 650         int mode = 0;
 651
 652         dbus_result = g_dbus_connection_call_finish(G_DBUS_CONNECTION(source_object), res, &error);
 653         TAPI_RESP_CHECK_ERROR(error, evt_cb_data);
 654
 655         g_variant_get(dbus_result, "(ii)", &mode, &result);
 656
 657         TAPI_INVOKE_RESP_CALLBACK(evt_cb_data, result, &mode);
 658
 659         g_free(evt_cb_data);
 660         g_variant_unref(dbus_result);
 661 }
 662
 663 static void on_response_get_network_serving(GObject *source_object,
 664                 GAsyncResult *res, gpointer user_data)
 665 {
 666         GError *error = NULL;
 667         struct tapi_resp_data *evt_cb_data = user_data;
 668         int result = -1;
 669
 670         TelNetworkServing_t data;
 671
 672         GVariantIter *iter;
 673         GVariant *value = NULL;
 674         const gchar *key = NULL;
 675         GVariant *dbus_result;
 676         char *plmn;
 677         int v0, v4, v5;
 678         char v1, v2, v3, v6, v7;
 679
 680         memset(&data, 0, sizeof(TelNetworkServing_t));
 681
 682         dbus_result = g_dbus_connection_call_finish(G_DBUS_CONNECTION(source_object), res, &error);
 683         TAPI_RESP_CHECK_ERROR(error, evt_cb_data);
 684
 685         g_variant_get(dbus_result, "(a{sv}i)", &iter, &result);
 686
 687         while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
 688                 if (!g_strcmp0(key, "serving")) {
 689                         g_variant_get(value, "(is)", &v0, &plmn);
 690                         data.act = _convert_act_to_systemtype(v0);
 691                         if (plmn) {
 692                                 snprintf(data.plmn, 7, "%s", plmn);
 693                                 g_free(plmn);
 694                         }
 695                 } else if (!g_strcmp0(key, "g_serving")) {
 696                         g_variant_get(value, "(i)", &v0);
 697                         data.info.lac = v0;
 698                 } else if (!g_strcmp0(key, "c_serving")) {
 699                         g_variant_get(value, "(iuuuiiuu)", &v0, &v1, &v2, &v3, &v4, &v5, &v6, &v7);
 700                         data.info.cdma_info.carrier = v0;
 701                         data.info.cdma_info.system_id = v1;
 702                         data.info.cdma_info.network_id = v2;
 703                         data.info.cdma_info.base_station_id = v3;
 704                         data.info.cdma_info.base_station_latitude = v4;
 705                         data.info.cdma_info.base_station_longitude = v5;
 706                         data.info.cdma_info.registration_zone = v6;
 707                         data.info.cdma_info.pilot_offset = v7;
 708                 }
 709         }
 710         g_variant_iter_free(iter);
 711
 712         TAPI_INVOKE_RESP_CALLBACK(evt_cb_data, result, &data);
 713
 714         g_free(evt_cb_data);
 715         g_variant_unref(dbus_result);
 716 }
 717
 718 static void on_response_get_neighboring_cell_info(GObject *source_object,
 719                 GAsyncResult *res, gpointer user_data)
 720 {
 721         GError *error = NULL;
 722         struct tapi_resp_data *evt_cb_data = user_data;
 723         int result = -1;
 724         int geran_index = 0, umts_index = 0;
 725
 726         TelNetworkNeighboringCellInfo_t list;
 727
 728         GVariant *dbus_result = NULL;
 729         GVariant *value = NULL;
 730         GVariantIter *iter = NULL;
 731         GVariantIter *iter_row = NULL;
 732         const gchar *key = NULL;
 733         gint v0, v1, v2, v3, v4, v5;
 734
 735         memset(&list, 0, sizeof(TelNetworkNeighboringCellInfo_t));
 736
 737         dbus_result = g_dbus_connection_call_finish(G_DBUS_CONNECTION(source_object), res, &error);
 738         TAPI_RESP_CHECK_ERROR(error, evt_cb_data);
 739
 740         g_variant_get(dbus_result, "(aa{sv}i)", &iter, &result);
 741
 742         while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
 743                 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
 744                         if (!g_strcmp0(key, "serving")) {
 745                                 g_variant_get(value, "(iii)", &v0, &v1, &v2);
 746                                 list.serving.act = _convert_act_to_systemtype(v0);
 747                                 list.serving.mcc = v1;
 748                                 list.serving.mnc = v2;
 749                         } else if (!g_strcmp0(key, "g_serving")) {
 750                                 g_variant_get(value, "(iiiii)", &v0, &v1, &v2, &v3, &v4);
 751                                 list.serving.cell.geran.cell_id = v0;
 752                                 list.serving.cell.geran.lac = v1;
 753                                 list.serving.cell.geran.bcch = v2;
 754                                 list.serving.cell.geran.bsic = v3;
 755                                 list.serving.cell.geran.rxlev = v4;
 756                         } else if (!g_strcmp0(key, "u_serving")) {
 757                                 g_variant_get(value, "(iiiii)", &v0, &v1, &v2, &v3, &v4);
 758                                 list.serving.cell.umts.cell_id = v0;
 759                                 list.serving.cell.umts.lac = v1;
 760                                 list.serving.cell.umts.arfcn = v2;
 761                                 list.serving.cell.umts.psc = v3;
 762                                 list.serving.cell.umts.rscp = v4;
 763                         } else if (!g_strcmp0(key, "l_serving")) {
 764                                 g_variant_get(value, "(iiiii)", &v0, &v1, &v2, &v3, &v4);
 765                                 list.serving.cell.lte.cell_id = v0;
 766                                 list.serving.cell.lte.lac = v1;
 767                                 list.serving.cell.lte.earfcn = v2;
 768                                 list.serving.cell.lte.tac = v3;
 769                                 list.serving.cell.lte.rssi = v4;
 770                         } else if (!g_strcmp0(key, "c_serving")) {
 771                                 g_variant_get(value, "(uuuuii)", &v0, &v1, &v2, &v3, &v4, &v5);
 772                                 list.serving.cell.cdma.system_id = v0;
 773                                 list.serving.cell.cdma.network_id = v1;
 774                                 list.serving.cell.cdma.base_station_id = v2;
 775                                 list.serving.cell.cdma.reference_pn = v3;
 776                                 list.serving.cell.cdma.base_station_latitude = v4;
 777                                 list.serving.cell.cdma.base_station_longitude = v5;
 778                         } else if (!g_strcmp0(key, "geran")) {
 779                                 g_variant_get(value, "(iiiii)", &v0, &v1, &v2, &v3, &v4);
 780                                 list.geran_list[geran_index].cell_id = v0;
 781                                 list.geran_list[geran_index].lac = v1;
 782                                 list.geran_list[geran_index].bcch = v2;
 783                                 list.geran_list[geran_index].bsic = v3;
 784                                 list.geran_list[geran_index].rxlev = v4;
 785                                 geran_index++;
 786                         } else if (!g_strcmp0(key, "umts")) {
 787                                 g_variant_get(value, "(iiiii)", &v0, &v1, &v2, &v3, &v4);
 788                                 list.umts_list[umts_index].cell_id = v0;
 789                                 list.umts_list[umts_index].lac   = v1;
 790                                 list.umts_list[umts_index].arfcn = v2;
 791                                 list.umts_list[umts_index].psc = v3;
 792                                 list.umts_list[umts_index].rscp = v4;
 793                                 umts_index++;
 794                         }
 795                 }
 796                 g_variant_iter_free(iter_row);
 797         }
 798         g_variant_iter_free(iter);
 799
 800         list.geran_list_count = geran_index;
 801         list.umts_list_count = umts_index;
 802         dbg("act=%d, count(geran:%d, umts:%d)", list.serving.act, geran_index, umts_index);
 803
 804         TAPI_INVOKE_RESP_CALLBACK(evt_cb_data, result, &list);
 805
 806         g_free(evt_cb_data);
 807         g_variant_unref(dbus_result);
 808 }
 809
 810 static void on_response_select_network(GObject *source_object, GAsyncResult *res,
 811         gpointer user_data)
 812 {
 813         GError *error = NULL;
 814         struct tapi_resp_data *evt_cb_data = user_data;
 815         int result = -1;
 816         GVariant *dbus_result;
 817
 818         dbus_result = g_dbus_connection_call_finish(G_DBUS_CONNECTION(source_object), res, &error);
 819         TAPI_RESP_CHECK_ERROR(error, evt_cb_data);
 820         g_variant_get(dbus_result, "(i)", &result);
 821
 822         /* Map result received from libtcore to TapiResult_t */
 823         if (result == 0) {
 824                 result = TAPI_API_SUCCESS;
 825         } else {
 826                 switch (result) {
 827                 case 0x50000001:
 828                         result = TAPI_API_NETWORK_PLMN_NOT_ALLOWED;
 829                 break;
 830
 831                 case 0x50000002:
 832                         result = TAPI_API_NETWORK_ROAMING_NOT_ALLOWED;
 833                 break;
 834
 835                 default:
 836                         /*Do Nothing*/
 837                 break;
 838                 }
 839         }
 840
 841         TAPI_INVOKE_RESP_CALLBACK(evt_cb_data, result, NULL);
 842
 843         g_free(evt_cb_data);
 844         g_variant_unref(dbus_result);
 845 }
 846
 847 static void on_response_get_network_roaming_preference(GObject *source_object,
 848                 GAsyncResult *res, gpointer user_data)
 849 {
 850         GError *error = NULL;
 851         struct tapi_resp_data *evt_cb_data = user_data;
 852         int result = -1;
 853
 854         GVariant *dbus_result;
 855         TelNetworkPrefNetType_t roam_pref;
 856
 857         dbus_result = g_dbus_connection_call_finish(G_DBUS_CONNECTION(source_object), res, &error);
 858         TAPI_RESP_CHECK_ERROR(error, evt_cb_data);
 859
 860         g_variant_get(dbus_result, "(ii)", &roam_pref, &result);
 861
 862         TAPI_INVOKE_RESP_CALLBACK(evt_cb_data, result, &roam_pref);
 863
 864         g_free(evt_cb_data);
 865         g_variant_unref(dbus_result);
 866 }
 867
 868 EXPORT_API int tel_search_network(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 869 {
 870         struct tapi_resp_data *evt_cb_data = NULL;
 871
 872         TAPI_RET_ERR_NUM_IF_FAIL(handle != NULL && callback != NULL, TAPI_API_INVALID_PTR);
 873
 874         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 875
 876         msg("[%s] network_search requested", handle->cp_name);
 877
 878         g_dbus_connection_call(handle->dbus_connection,
 879                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 880                         "Search", NULL, NULL,
 881                         G_DBUS_CALL_FLAGS_NONE, TAPI_UNRESTRICTED_TIMEOUT, handle->ca,
 882                         on_response_search_network, evt_cb_data);
 883
 884         return TAPI_API_SUCCESS;
 885 }
 886
 887 EXPORT_API int tel_get_network_selection_mode(struct tapi_handle *handle, tapi_response_cb callback, void *user_data)
 888 {
 889         struct tapi_resp_data *evt_cb_data = NULL;
 890
 891         dbg("Func Entrance");
 892
 893         TAPI_RET_ERR_NUM_IF_FAIL(handle != NULL && callback != NULL, TAPI_API_INVALID_PTR);
 894
 895         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 896
 897         g_dbus_connection_call(handle->dbus_connection,
 898                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 899                         "GetSelectionMode", NULL, NULL,
 900                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 901                         on_response_get_network_selection_mode, evt_cb_data);
 902
 903         return TAPI_API_SUCCESS;
 904 }
 905
 906 EXPORT_API int tel_select_network_automatic(struct tapi_handle *handle, tapi_response_cb callback, void *user_data)
 907 {
 908         struct tapi_resp_data *evt_cb_data = NULL;
 909         GVariant *param;
 910
 911         TAPI_RET_ERR_NUM_IF_FAIL(handle != NULL, TAPI_API_INVALID_PTR);
 912
 913         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 914
 915         param = g_variant_new("(isi)",
 916                         0, /* Automatic */
 917                         "",
 918                         0);
 919
 920         msg("[%s] automatic selection requested", handle->cp_name);
 921
 922         g_dbus_connection_call(handle->dbus_connection,
 923                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 924                         "SetSelectionMode", param, NULL,
 925                         G_DBUS_CALL_FLAGS_NONE, TAPI_UNRESTRICTED_TIMEOUT, handle->ca,
 926                         on_response_default_set, evt_cb_data);
 927
 928         return TAPI_API_SUCCESS;
 929 }
 930
 931 EXPORT_API int tel_select_network_manual(struct tapi_handle *handle, const char *plmn, int type, tapi_response_cb callback, void *user_data)
 932 {
 933         struct tapi_resp_data *evt_cb_data = NULL;
 934         GVariant *param;
 935
 936         TAPI_RET_ERR_NUM_IF_FAIL(handle != NULL && _check_plmn(plmn), TAPI_API_INVALID_PTR);
 937
 938         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 939
 940         param = g_variant_new("(isi)",
 941                         1, /* Manual */
 942                         plmn,
 943                         _convert_systemtype_to_act(type));
 944
 945         msg("[%s] manual selection requested plmn:[%s] type:[%d]", handle->cp_name, plmn ? plmn : "", type);
 946
 947         g_dbus_connection_call(handle->dbus_connection,
 948                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 949                         "SetSelectionMode", param, NULL,
 950                         G_DBUS_CALL_FLAGS_NONE, TAPI_UNRESTRICTED_TIMEOUT, handle->ca,
 951                         on_response_select_network, evt_cb_data);
 952
 953         return TAPI_API_SUCCESS;
 954 }
 955
 956 EXPORT_API int tel_set_network_preferred_plmn(
 957                 TapiHandle *handle,
 958                 TelNetworkPreferredPlmnOp_t operation,
 959                 TelNetworkPreferredPlmnInfo_t *info,
 960                 tapi_response_cb callback,
 961                 void *user_data)
 962 {
 963         struct tapi_resp_data *evt_cb_data = NULL;
 964         GVariant *param;
 965         int act = 0;
 966
 967         TAPI_RET_ERR_NUM_IF_FAIL(handle != NULL && info != NULL &&
 968                                                         _check_operation(operation) &&
 969                                                         _check_plmn((const char *)&info->Plmn), TAPI_API_INVALID_PTR);
 970
 971         dbg("Func Entrance");
 972
 973         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 974
 975         switch (info->SystemType) {
 976         case TAPI_NETWORK_SYSTEM_GSM:
 977                 act = 1;
 978         break;
 979
 980         case TAPI_NETWORK_SYSTEM_UMTS:
 981                 act = 4;
 982         break;
 983
 984         case TAPI_NETWORK_SYSTEM_GPRS:
 985                 act = 2;
 986         break;
 987
 988         case TAPI_NETWORK_SYSTEM_EGPRS:
 989                 act = 3;
 990         break;
 991
 992         case TAPI_NETWORK_SYSTEM_GSM_AND_UMTS:
 993                 act = 4;
 994         break;
 995
 996         default:
 997                 act = 4;
 998         break;
 999         }
1000
1001         param = g_variant_new("(iiis)",
1002                         operation,
1003                         info->Index,
1004                         act,
1005                         info->Plmn);
1006
1007         g_dbus_connection_call(handle->dbus_connection,
1008                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
1009                         "SetPreferredPlmn", param, NULL,
1010                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1011                         on_response_default_set, evt_cb_data);
1012
1013         return TAPI_API_SUCCESS;
1014 }
1015
1016 EXPORT_API int tel_get_network_preferred_plmn(TapiHandle *handle, tapi_response_cb callback, void *user_data)
1017 {
1018         struct tapi_resp_data *evt_cb_data = NULL;
1019
1020         dbg("Func Entrance");
1021
1022         TAPI_RET_ERR_NUM_IF_FAIL(handle != NULL && callback != NULL, TAPI_API_INVALID_PTR);
1023
1024         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1025
1026         g_dbus_connection_call(handle->dbus_connection,
1027                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
1028                         "GetPreferredPlmn", NULL, NULL,
1029                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1030                         on_response_get_network_preferred_plmn, evt_cb_data);
1031
1032         return TAPI_API_SUCCESS;
1033 }
1034
1035 EXPORT_API int tel_set_network_mode(TapiHandle *handle, int mode, tapi_response_cb callback, void *user_data)
1036 {
1037         struct tapi_resp_data *evt_cb_data = NULL;
1038         GVariant *param;
1039
1040         TAPI_RET_ERR_NUM_IF_FAIL(handle != NULL &&
1041                                                                 _check_network_mode(mode), TAPI_API_INVALID_PTR);
1042
1043         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1044
1045         param = g_variant_new("(i)",
1046                         mode);
1047
1048         msg("[%s] requested mode:[0x%x]", handle->cp_name, mode);
1049
1050         g_dbus_connection_call(handle->dbus_connection,
1051                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
1052                         "SetMode", param, NULL,
1053                         G_DBUS_CALL_FLAGS_NONE, TAPI_UNRESTRICTED_TIMEOUT, handle->ca,
1054                         on_response_default_set, evt_cb_data);
1055
1056         return TAPI_API_SUCCESS;
1057 }
1058
1059 EXPORT_API int tel_get_network_mode(TapiHandle *handle, tapi_response_cb callback, void *user_data)
1060 {
1061         struct tapi_resp_data *evt_cb_data = NULL;
1062
1063         TAPI_RET_ERR_NUM_IF_FAIL(handle != NULL && callback != NULL, TAPI_API_INVALID_PTR);
1064
1065         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1066
1067         dbg("[%s] Func Entrance", handle->cp_name);
1068
1069         g_dbus_connection_call(handle->dbus_connection,
1070                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
1071                         "GetMode", NULL, NULL,
1072                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1073                         on_response_get_network_mode, evt_cb_data);
1074
1075         return TAPI_API_SUCCESS;
1076 }
1077
1078 EXPORT_API int tel_cancel_network_manual_search(TapiHandle *handle, tapi_response_cb callback, void *user_data)
1079 {
1080         struct tapi_resp_data *evt_cb_data = NULL;
1081
1082         TAPI_RET_ERR_NUM_IF_FAIL(handle != NULL, TAPI_API_INVALID_PTR);
1083
1084         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1085
1086         msg("[%s] network search cancel requested", handle->cp_name);
1087
1088         g_dbus_connection_call(handle->dbus_connection,
1089                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
1090                         "SearchCancel", NULL, NULL,
1091                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1092                         on_response_default_set, evt_cb_data);
1093
1094         return TAPI_API_SUCCESS;
1095 }
1096
1097 EXPORT_API int tel_get_network_serving(TapiHandle *handle, tapi_response_cb callback, void *user_data)
1098 {
1099         struct tapi_resp_data *evt_cb_data = NULL;
1100
1101         TAPI_RET_ERR_NUM_IF_FAIL(handle != NULL && callback != NULL, TAPI_API_INVALID_PTR);
1102
1103         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1104
1105         dbg("[%s] Func Entrance", handle->cp_name);
1106
1107         g_dbus_connection_call(handle->dbus_connection,
1108                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
1109                         "GetServingNetwork", NULL, NULL,
1110                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1111                         on_response_get_network_serving, evt_cb_data);
1112
1113         return TAPI_API_SUCCESS;
1114 }
1115
1116 EXPORT_API int tel_get_network_neighboring_cell_info(TapiHandle *handle, tapi_response_cb callback, void *user_data)
1117 {
1118         struct tapi_resp_data *evt_cb_data = NULL;
1119
1120         TAPI_RET_ERR_NUM_IF_FAIL(handle != NULL && callback != NULL, TAPI_API_INVALID_PTR);
1121
1122         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1123
1124         dbg("[%s] Func Entrance", handle->cp_name);
1125
1126         g_dbus_connection_call(handle->dbus_connection,
1127                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
1128                         "GetNgbrCellInfo", NULL, NULL,
1129                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1130                         on_response_get_neighboring_cell_info, evt_cb_data);
1131
1132         return TAPI_API_SUCCESS;
1133 }
1134
1135 EXPORT_API int tel_set_network_default_data_subscription(TapiHandle *handle, tapi_response_cb callback, void *user_data)
1136 {
1137         struct tapi_resp_data *evt_cb_data = NULL;
1138
1139         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1140         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
1141
1142         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1143
1144         msg("[%s] Func Entrance", handle->cp_name);
1145
1146         /* DBUS call */
1147         g_dbus_connection_call(handle->dbus_connection,
1148                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
1149                         "SetDefaultDataSubscription", NULL, NULL,
1150                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1151                         on_response_default_set, evt_cb_data);
1152
1153         return TAPI_API_SUCCESS;
1154 }
1155
1156 EXPORT_API int tel_set_network_emergency_callback_mode(TapiHandle *handle, TelNetworkEmergencyCallbackMode_t mode, tapi_response_cb callback, void *user_data)
1157 {
1158         struct tapi_resp_data *evt_cb_data = NULL;
1159         GVariant *param;
1160
1161         TAPI_RET_ERR_NUM_IF_FAIL(handle != NULL &&
1162                                                                 _check_emergency_callback_mode(mode), TAPI_API_INVALID_PTR);
1163
1164         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1165
1166         param = g_variant_new("(i)", mode);
1167
1168         msg("[%s] emergency callback mode :[%d]", handle->cp_name, mode);
1169
1170         g_dbus_connection_call(handle->dbus_connection,
1171                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
1172                         "SetEmergencyCallbackMode", param, NULL,
1173                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1174                         on_response_default_set, evt_cb_data);
1175
1176         return TAPI_API_SUCCESS;
1177 }
1178
1179 EXPORT_API int tel_set_network_roaming_preference(TapiHandle *handle, TelNetworkPrefNetType_t roam_pref, tapi_response_cb callback, void *user_data)
1180 {
1181         struct tapi_resp_data *evt_cb_data = NULL;
1182         GVariant *param;
1183
1184         TAPI_RET_ERR_NUM_IF_FAIL(handle != NULL &&
1185                                                                 _check_roaming_preference(roam_pref), TAPI_API_INVALID_PTR);
1186
1187         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1188
1189         param = g_variant_new("(i)", roam_pref);
1190
1191         msg("[%s] roam_pref:[%d]", handle->cp_name, roam_pref);
1192
1193         g_dbus_connection_call(handle->dbus_connection,
1194                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
1195                         "SetRoamingPreference", param, NULL,
1196                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1197                         on_response_default_set, evt_cb_data);
1198
1199         return TAPI_API_SUCCESS;
1200
1201 }
1202
1203 EXPORT_API int tel_get_network_roaming_preference(TapiHandle *handle, tapi_response_cb callback, void *user_data)
1204 {
1205         struct tapi_resp_data *evt_cb_data = NULL;
1206
1207         TAPI_RET_ERR_NUM_IF_FAIL(handle != NULL && callback != NULL, TAPI_API_INVALID_PTR);
1208
1209         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1210
1211         dbg("[%s] Func Entrance", handle->cp_name);
1212
1213         g_dbus_connection_call(handle->dbus_connection,
1214                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
1215                         "GetRoamingPreference", NULL, NULL,
1216                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1217                         on_response_get_network_roaming_preference, evt_cb_data);
1218
1219         return TAPI_API_SUCCESS;
1220
1221 }
1222
1223 EXPORT_API int tel_get_network_default_data_subscription(TapiHandle *handle, TelNetworkDefaultDataSubs_t *default_subscription)
1224 {
1225         GError *gerr = NULL;
1226         GVariant *sync_gv = NULL;
1227         int subs = 0;
1228         int result = 0;
1229         TapiResult_t ret = TAPI_API_OPERATION_FAILED;
1230
1231         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1232         TAPI_RET_ERR_NUM_IF_FAIL(default_subscription, TAPI_API_INVALID_PTR);
1233
1234         sync_gv = g_dbus_connection_call_sync(handle->dbus_connection,
1235                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
1236                         "GetDefaultDataSubscription", NULL, NULL,
1237                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1238                         &gerr);
1239         if (sync_gv) {
1240                 g_variant_get(sync_gv, "(ii)", &subs, &result);
1241
1242                 if (result == 0)
1243                         *default_subscription = subs;
1244                 else
1245                         *default_subscription = TAPI_NETWORK_DEFAULT_DATA_SUBS_UNKNOWN;
1246
1247                 msg("'default' Data Subscription: [%d]", subs);
1248
1249                 g_variant_unref(sync_gv);
1250                 ret = TAPI_API_SUCCESS;
1251         } else {
1252                 err("Get Data Subscription failed: [%s]", gerr->message);
1253                 if (strstr(gerr->message, "AccessDenied"))
1254                         ret = TAPI_API_ACCESS_DENIED;
1255                 g_error_free(gerr);
1256         }
1257
1258         return ret;
1259 }
1260
1261 EXPORT_API int tel_set_network_default_subscription(TapiHandle *handle, tapi_response_cb callback, void *user_data)
1262 {
1263         struct tapi_resp_data *evt_cb_data = NULL;
1264
1265         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1266         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
1267
1268         TAPI_MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1269
1270         dbg("[%s] Set 'default' Subscription (for CS)", handle->cp_name);
1271
1272         /* DBUS call */
1273         g_dbus_connection_call(handle->dbus_connection,
1274                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
1275                         "SetDefaultSubscription", NULL, NULL,
1276                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1277                         on_response_default_set, evt_cb_data);
1278
1279         return TAPI_API_SUCCESS;
1280 }
1281
1282 EXPORT_API int tel_get_network_default_subscription(TapiHandle *handle, TelNetworkDefaultSubs_t *default_subscription)
1283 {
1284         GError *gerr = NULL;
1285         GVariant *sync_gv = NULL;
1286         int subs = 0;
1287         int result = 0;
1288         TapiResult_t ret = TAPI_API_OPERATION_FAILED;
1289
1290         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1291         TAPI_RET_ERR_NUM_IF_FAIL(default_subscription, TAPI_API_INVALID_PTR);
1292
1293         sync_gv = g_dbus_connection_call_sync(handle->dbus_connection,
1294                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
1295                         "GetDefaultSubscription", NULL, NULL,
1296                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1297                         &gerr);
1298         if (sync_gv) {
1299                 g_variant_get(sync_gv, "(ii)", &subs, &result);
1300
1301                 if (result == 0)
1302                         *default_subscription = subs;
1303                 else
1304                         *default_subscription = TAPI_NETWORK_DEFAULT_SUBS_UNKNOWN;
1305                 dbg("'default' Subscription (for CS): [%d]", subs);
1306
1307                 g_variant_unref(sync_gv);
1308                 ret = TAPI_API_SUCCESS;
1309         } else {
1310                 err("Get 'default' Subscription (for CS) failed: [%s]", gerr->message);
1311                 if (strstr(gerr->message, "AccessDenied"))
1312                         ret = TAPI_API_ACCESS_DENIED;
1313                 g_error_free(gerr);
1314         }
1315
1316         return ret;
1317 }