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         CALLBACK_CALL(&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         CALLBACK_CALL(&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         CALLBACK_CALL(&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         CALLBACK_CALL(&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         CALLBACK_CALL(&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         CALLBACK_CALL(&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         CALLBACK_CALL(&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         CALLBACK_CALL(&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         CALLBACK_CALL(&noti);
 289 }
 290
 291 static struct signal_map signals[] = {
 292         { "RegistrationStatus", on_signal_registration_status },
 293         { "SignalStrength", on_signal_strength },
 294         { "CellInfo", on_signal_cell_info },
 295         { "Change", on_signal_change },
 296         { "TimeInfo", on_signal_time_info },
 297         { "Identity", on_signal_identity },
 298         { "EmergencyCallbackMode", on_emergency_callback_mode },
 299         { "DefaultDataSubscription", on_signal_default_data_subscription },
 300         { "DefaultSubscription", on_signal_default_subscription },
 301 };
 302
 303 void _process_network_event(const gchar *sig, GVariant *param,
 304         TapiHandle *handle, char *noti_id, struct tapi_evt_cb *evt_cb_data)
 305 {
 306         unsigned int i;
 307         TAPI_RETURN_IF_FAIL(evt_cb_data);
 308
 309         for (i = 0; i < sizeof (signals) / sizeof (struct signal_map); i++) {
 310                 dbg("Received (%s)(%s) signal from telephony", handle->cp_name, sig);
 311                 if (!g_strcmp0 (sig, signals[i].signal_name)) {
 312                         signals[i].callback (handle, param, noti_id, evt_cb_data);
 313                         return;
 314                 }
 315         }
 316
 317         dbg("not handled NETWORK noti[%s]",sig );
 318 }
 319
 320 static gboolean _check_plmn(const char *plmn)
 321 {
 322         unsigned int plmn_len = 0;
 323
 324         if (plmn == NULL) {
 325                 err("PLMN is NULL");
 326                 return FALSE;
 327         }
 328
 329         plmn_len = strlen(plmn);
 330         if (plmn_len < 5 || plmn_len > 6) {
 331                 err("PLMN length(%d) is invalid", plmn_len);
 332                 return FALSE;
 333         }
 334
 335         return TRUE;
 336 }
 337
 338 static gboolean _check_operation(TelNetworkPreferredPlmnOp_t operation)
 339 {
 340         switch(operation) {
 341         case TAPI_NETWORK_PREF_PLMN_ADD:
 342         case TAPI_NETWORK_PREF_PLMN_EDIT:
 343         case TAPI_NETWORK_PREF_PLMN_DELETE:
 344                 return TRUE;
 345         default:
 346                 /*Do Nothing*/
 347                 err("Default Case executed. Unknown PLMN Op");
 348                 break;
 349         }
 350         err("operation %d is not supported", operation);
 351         return FALSE;
 352 }
 353
 354 static gboolean _check_network_mode(int mode)
 355 {
 356         if (mode == TAPI_NETWORK_MODE_AUTO) {
 357                 return TRUE;
 358         } else {
 359                 if (mode & TAPI_NETWORK_MODE_GSM) {
 360                         mode &= ~TAPI_NETWORK_MODE_GSM;
 361                 }
 362                 if (mode & TAPI_NETWORK_MODE_WCDMA) {
 363                         mode &= ~TAPI_NETWORK_MODE_WCDMA;
 364                 }
 365                 if (mode & TAPI_NETWORK_MODE_1XRTT) {
 366                         mode &= ~TAPI_NETWORK_MODE_1XRTT;
 367                 }
 368                 if (mode & TAPI_NETWORK_MODE_LTE) {
 369                         mode &= ~TAPI_NETWORK_MODE_LTE;
 370                 }
 371                 if (mode & TAPI_NETWORK_MODE_EVDO) {
 372                         mode &= ~TAPI_NETWORK_MODE_EVDO;
 373                 }
 374                 if (mode == 0)
 375                         return TRUE;
 376         }
 377         err("mode %d is not supported", mode);
 378         return FALSE;
 379 }
 380
 381 static gboolean _check_emergency_callback_mode(TelNetworkEmergencyCallbackMode_t mode)
 382 {
 383         switch(mode) {
 384         case TAPI_NETWORK_EMERGENCY_CALLBACK_MODE_ENTER:
 385         case TAPI_NETWORK_EMERGENCY_CALLBACK_MODE_EXIT:
 386                 return TRUE;
 387         default:
 388                 /*Do Nothing*/
 389                 err("Default Case executed. Unknown Emergency callback mode");
 390                 break;
 391         }
 392         err("emergency callback mode %d is not supported", mode);
 393         return FALSE;
 394 }
 395
 396 static gboolean _check_roaming_preference(TelNetworkPrefNetType_t roam_pref)
 397 {
 398         switch(roam_pref) {
 399         case TAPI_NETWORK_PREF_NET_TYPE_HOME_ONLY:
 400         case TAPI_NETWORK_PREF_NET_TYPE_AFFILIATED:
 401         case TAPI_NETWORK_PREF_NET_TYPE_AUTOMATIC:
 402         case TAPI_NETWORK_PREF_NET_TYPE_AUTOMATIC_A:
 403         case TAPI_NETWORK_PREF_NET_TYPE_AUTOMATIC_B:
 404         case TAPI_NETWORK_PREF_NET_TYPE_ROAM_DOMESTIC:
 405         case TAPI_NETWORK_PREF_NET_TYPE_ROAM_INTERNATIONAL:
 406         case TAPI_NETWORK_PREF_NET_TYPE_ROAM_DUAL:
 407         case TAPI_NETWORK_PREF_NET_TYPE_BLANK:
 408                 return TRUE;
 409         default:
 410                 /*Do Nothing*/
 411                 err("Default Case executed. Unknown roaming preference");
 412                 break;
 413         }
 414         err("roam_pref %d is not supported", roam_pref);
 415         return FALSE;
 416 }
 417
 418 static void on_response_search_network (GObject *source_object,
 419                 GAsyncResult *res, gpointer user_data)
 420 {
 421         GError *error = NULL;
 422         struct tapi_resp_data *evt_cb_data = user_data;
 423         int result = -1;
 424         int i;
 425
 426         TelNetworkPlmnList_t list;
 427
 428         GVariant *dbus_result = NULL;
 429         GVariant *value = NULL;
 430         GVariantIter *iter = NULL;
 431         GVariantIter *iter_row = NULL;
 432         const gchar *key = NULL;
 433
 434         memset (&list, 0, sizeof(TelNetworkPlmnList_t));
 435
 436         dbus_result = g_dbus_connection_call_finish (
 437                         G_DBUS_CONNECTION (source_object), res, &error);
 438         CHECK_ERROR(error);
 439
 440         g_variant_get (dbus_result, "(aa{sv}i)", &iter, &result);
 441
 442         list.networks_count = g_variant_iter_n_children(iter);
 443
 444         i = 0;
 445         while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
 446                 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
 447                         if (!g_strcmp0(key, "plmn")) {
 448                                 strncpy(list.network_list[i].plmn, g_variant_get_string(value, NULL), TAPI_NETWORK_PLMN_LEN_MAX);
 449                                 list.network_list[i].plmn_id = atoi(g_variant_get_string(value, NULL));
 450                         }
 451                         if (!g_strcmp0(key, "act")) {
 452                                 list.network_list[i].access_technology = _convert_act_to_systemtype(g_variant_get_int32(value));
 453                         }
 454                         if (!g_strcmp0(key, "type")) {
 455                                 list.network_list[i].type_of_plmn = g_variant_get_int32(value);
 456                         }
 457                         if (!g_strcmp0(key, "name")) {
 458                                 strncpy(list.network_list[i].network_name, g_variant_get_string(value, NULL), 40);
 459                         }
 460                 }
 461                 i++;
 462                 g_variant_iter_free(iter_row);
 463         }
 464         g_variant_iter_free(iter);
 465
 466         if (evt_cb_data->cb_fn) {
 467                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &list, evt_cb_data->user_data);
 468         }
 469
 470         g_free(evt_cb_data);
 471         g_variant_unref(dbus_result);
 472 }
 473
 474 static void on_response_get_network_selection_mode (GObject *source_object,
 475                 GAsyncResult *res, gpointer user_data)
 476 {
 477         GError *error = NULL;
 478         struct tapi_resp_data *evt_cb_data = user_data;
 479         int result = -1;
 480
 481         GVariant *dbus_result;
 482         int mode = 0;
 483
 484         dbus_result = g_dbus_connection_call_finish (
 485                         G_DBUS_CONNECTION (source_object), res, &error);
 486         CHECK_ERROR(error);
 487
 488         g_variant_get (dbus_result, "(ii)", &mode, &result);
 489
 490         if (evt_cb_data->cb_fn) {
 491                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &mode, evt_cb_data->user_data);
 492         }
 493
 494         g_free(evt_cb_data);
 495         g_variant_unref(dbus_result);
 496 }
 497
 498 static void on_response_default_set (GObject *source_object, GAsyncResult *res,
 499                 gpointer user_data)
 500 {
 501         GError *error = NULL;
 502         struct tapi_resp_data *evt_cb_data = user_data;
 503         int result = -1;
 504
 505         GVariant *dbus_result;
 506
 507         dbus_result = g_dbus_connection_call_finish (
 508                         G_DBUS_CONNECTION (source_object), res, &error);
 509         CHECK_ERROR(error);
 510
 511         g_variant_get (dbus_result, "(i)", &result);
 512
 513         if (evt_cb_data->cb_fn) {
 514                 evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
 515         }
 516
 517         g_free(evt_cb_data);
 518         g_variant_unref(dbus_result);
 519 }
 520
 521 static void on_response_get_network_preferred_plmn (GObject *source_object,
 522                 GAsyncResult *res, gpointer user_data)
 523 {
 524         GError *error = NULL;
 525         struct tapi_resp_data *evt_cb_data = user_data;
 526         int result = -1;
 527         int i;
 528
 529         TelNetworkPreferredPlmnList_t list;
 530
 531         GVariant *dbus_result = NULL;
 532         GVariant *value = NULL;
 533         GVariantIter *iter = NULL;
 534         GVariantIter *iter_row = NULL;
 535         const gchar *key = NULL;
 536
 537         memset (&list, 0, sizeof(TelNetworkPreferredPlmnList_t));
 538
 539         dbus_result = g_dbus_connection_call_finish (
 540                         G_DBUS_CONNECTION (source_object), res, &error);
 541         CHECK_ERROR(error);
 542
 543         g_variant_get (dbus_result, "(aa{sv}i)", &iter, &result);
 544
 545         list.NumOfPrefPlmns = g_variant_iter_n_children(iter);
 546
 547         if (list.NumOfPrefPlmns == 0) {
 548                 dbg("num_of_.. = 0");
 549                 if (evt_cb_data->cb_fn) {
 550                         evt_cb_data->cb_fn(evt_cb_data->handle, result, &list, evt_cb_data->user_data);
 551                 }
 552
 553                 g_free(evt_cb_data);
 554                 return;
 555         }
 556
 557         i = 0;
 558         while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
 559                 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
 560                         if (!g_strcmp0(key, "plmn")) {
 561                                 strncpy(list.PrefPlmnRecord[i].Plmn, g_variant_get_string(value, NULL), 6);
 562                         }
 563                         if (!g_strcmp0(key, "act")) {
 564                                 list.PrefPlmnRecord[i].SystemType = _convert_act_to_systemtype(g_variant_get_int32(value));
 565                         }
 566                         if (!g_strcmp0(key, "index")) {
 567                                 list.PrefPlmnRecord[i].Index = g_variant_get_int32(value);
 568                         }
 569                         if (!g_strcmp0(key, "name")) {
 570                                 strncpy(list.PrefPlmnRecord[i].network_name, g_variant_get_string(value, NULL), 40);
 571                         }
 572                 }
 573                 i++;
 574                 g_variant_iter_free(iter_row);
 575         }
 576         g_variant_iter_free(iter);
 577
 578         if (evt_cb_data->cb_fn) {
 579                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &list, evt_cb_data->user_data);
 580         }
 581
 582         g_free(evt_cb_data);
 583         g_variant_unref(dbus_result);
 584 }
 585
 586 static void on_response_get_network_mode (GObject *source_object,
 587                 GAsyncResult *res, gpointer user_data)
 588 {
 589         GError *error = NULL;
 590         struct tapi_resp_data *evt_cb_data = user_data;
 591         int result = -1;
 592
 593         GVariant *dbus_result;
 594         int mode = 0;
 595
 596         dbus_result = g_dbus_connection_call_finish (
 597                         G_DBUS_CONNECTION (source_object), res, &error);
 598         CHECK_ERROR(error);
 599
 600         g_variant_get (dbus_result, "(ii)", &mode, &result);
 601
 602         if (evt_cb_data->cb_fn) {
 603                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &mode, evt_cb_data->user_data);
 604         }
 605
 606         g_free(evt_cb_data);
 607         g_variant_unref(dbus_result);
 608 }
 609
 610 static void on_response_get_network_serving (GObject *source_object,
 611                 GAsyncResult *res, gpointer user_data)
 612 {
 613         GError *error = NULL;
 614         struct tapi_resp_data *evt_cb_data = user_data;
 615         int result = -1;
 616
 617         TelNetworkServing_t data;
 618
 619         GVariant *dbus_result;
 620         char *plmn;
 621
 622         memset (&data, 0, sizeof(TelNetworkServing_t));
 623
 624         dbus_result = g_dbus_connection_call_finish (
 625                         G_DBUS_CONNECTION (source_object), res, &error);
 626         CHECK_ERROR(error);
 627
 628         g_variant_get (dbus_result, "(isii)",
 629                         &data.act,
 630                         &plmn,
 631                         &data.info.lac,
 632                         &result);
 633
 634         data.act = _convert_act_to_systemtype(data.act);
 635
 636         if (plmn) {
 637                 snprintf(data.plmn, 7, "%s", plmn);
 638                 g_free(plmn);
 639         }
 640
 641         if (evt_cb_data->cb_fn) {
 642                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
 643         }
 644
 645         g_free(evt_cb_data);
 646         g_variant_unref(dbus_result);
 647 }
 648
 649 static void on_response_get_neighboring_cell_info (GObject *source_object,
 650                 GAsyncResult *res, gpointer user_data)
 651 {
 652         GError *error = NULL;
 653         struct tapi_resp_data *evt_cb_data = user_data;
 654         int result = -1;
 655         int geran_index = 0, umts_index = 0;
 656
 657         TelNetworkNeighboringCellInfo_t list;
 658
 659         GVariant *dbus_result = NULL;
 660         GVariant *value = NULL;
 661         GVariantIter *iter = NULL;
 662         GVariantIter *iter_row = NULL;
 663         const gchar *key = NULL;
 664         gint v0, v1, v2, v3, v4;
 665
 666         memset (&list, 0, sizeof(TelNetworkNeighboringCellInfo_t));
 667
 668         dbus_result = g_dbus_connection_call_finish (
 669                         G_DBUS_CONNECTION (source_object), res, &error);
 670         CHECK_ERROR(error);
 671
 672         g_variant_get (dbus_result, "(aa{sv}i)", &iter, &result);
 673
 674         while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
 675                 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
 676                         if (!g_strcmp0(key, "serving")) {
 677                                 g_variant_get(value, "(iii)", &v0,&v1,&v2);
 678                                 list.serving.act = _convert_act_to_systemtype(v0);
 679                                 list.serving.mcc = v1;
 680                                 list.serving.mnc = v2;
 681                         }
 682                         else if (!g_strcmp0(key, "g_serving")) {
 683                                 g_variant_get(value, "(iiiii)", &v0,&v1,&v2,&v3,&v4);
 684                                 list.serving.cell.geran.cell_id = v0;
 685                                 list.serving.cell.geran.lac             = v1;
 686                                 list.serving.cell.geran.bcch    = v2;
 687                                 list.serving.cell.geran.bsic    = v3;
 688                                 list.serving.cell.geran.rxlev   = v4;
 689                         }
 690                         else if (!g_strcmp0(key, "u_serving")) {
 691                                 g_variant_get(value, "(iiiii)", &v0,&v1,&v2,&v3,&v4);
 692                                 list.serving.cell.umts.cell_id  = v0;
 693                                 list.serving.cell.umts.lac              = v1;
 694                                 list.serving.cell.umts.arfcn    = v2;
 695                                 list.serving.cell.umts.psc              = v3;
 696                                 list.serving.cell.umts.rscp             = v4;
 697                         }
 698                         else if (!g_strcmp0(key, "l_serving")) {
 699                                 g_variant_get(value, "(iiiii)", &v0,&v1,&v2,&v3,&v4);
 700                                 list.serving.cell.lte.cell_id   = v0;
 701                                 list.serving.cell.lte.lac               = v1;
 702                                 list.serving.cell.lte.earfcn    = v2;
 703                                 list.serving.cell.lte.tac               = v3;
 704                                 list.serving.cell.lte.rssi              = v4;
 705                         }
 706                         else if (!g_strcmp0(key, "geran")) {
 707                                 g_variant_get(value, "(iiiii)", &v0,&v1,&v2,&v3,&v4);
 708                                 list.geran_list[geran_index].cell_id    = v0;
 709                                 list.geran_list[geran_index].lac                = v1;
 710                                 list.geran_list[geran_index].bcch               = v2;
 711                                 list.geran_list[geran_index].bsic               = v3;
 712                                 list.geran_list[geran_index].rxlev              = v4;
 713                                 geran_index++;
 714                         }
 715                         else if (!g_strcmp0(key, "umts")) {
 716                                 g_variant_get(value, "(iiiii)", &v0,&v1,&v2,&v3,&v4);
 717                                 list.umts_list[umts_index].cell_id      = v0;
 718                                 list.umts_list[umts_index].lac          = v1;
 719                                 list.umts_list[umts_index].arfcn        = v2;
 720                                 list.umts_list[umts_index].psc          = v3;
 721                                 list.umts_list[umts_index].rscp         = v4;
 722                                 umts_index++;
 723                         }
 724                 }
 725                 g_variant_iter_free(iter_row);
 726         }
 727         g_variant_iter_free(iter);
 728
 729         list.geran_list_count = geran_index;
 730         list.umts_list_count = umts_index;
 731         dbg("act=%d, count(geran:%d, umts:%d)", list.serving.act, geran_index, umts_index);
 732
 733         if (evt_cb_data->cb_fn) {
 734                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &list, evt_cb_data->user_data);
 735         }
 736
 737         g_free(evt_cb_data);
 738         g_variant_unref(dbus_result);
 739 }
 740
 741 static void on_response_select_network (GObject *source_object, GAsyncResult *res,
 742         gpointer user_data)
 743 {
 744         GError *error = NULL;
 745         struct tapi_resp_data *evt_cb_data = user_data;
 746         int result = -1;
 747         GVariant *dbus_result;
 748
 749         dbus_result = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object), res, &error);
 750         CHECK_ERROR(error);
 751         g_variant_get (dbus_result, "(i)", &result);
 752
 753         /* Map result received from libtcore to TapiResult_t */
 754         if (result == 0)
 755                 result = TAPI_API_SUCCESS;
 756         else {
 757                 switch (result) {
 758                         case 0x50000001:
 759                                 result = TAPI_API_NETWORK_PLMN_NOT_ALLOWED;
 760                                 break;
 761                         case 0x50000002:
 762                                 result = TAPI_API_NETWORK_ROAMING_NOT_ALLOWED;
 763                                 break;
 764                         default:
 765                                 /*Do Nothing*/
 766                                 break;
 767                 }
 768         }
 769         if (evt_cb_data->cb_fn) {
 770                 evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
 771         }
 772         g_free(evt_cb_data);
 773         g_variant_unref(dbus_result);
 774 }
 775
 776 static void on_response_get_network_roaming_preference (GObject *source_object,
 777                 GAsyncResult *res, gpointer user_data)
 778 {
 779         GError *error = NULL;
 780         struct tapi_resp_data *evt_cb_data = user_data;
 781         int result = -1;
 782
 783         GVariant *dbus_result;
 784         TelNetworkPrefNetType_t roam_pref;
 785
 786         dbus_result = g_dbus_connection_call_finish (
 787                         G_DBUS_CONNECTION (source_object), res, &error);
 788         CHECK_ERROR(error);
 789
 790         g_variant_get (dbus_result, "(ii)", &roam_pref, &result);
 791
 792         if (evt_cb_data->cb_fn) {
 793                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &roam_pref, evt_cb_data->user_data);
 794         }
 795
 796         g_free(evt_cb_data);
 797         g_variant_unref(dbus_result);
 798 }
 799
 800 EXPORT_API int tel_search_network(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 801 {
 802         struct tapi_resp_data *evt_cb_data = NULL;
 803
 804         TAPI_RET_ERR_NUM_IF_FAIL(handle != NULL && callback != NULL, TAPI_API_INVALID_PTR);
 805
 806         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 807
 808         msg("[%s] network_search requested", handle->cp_name);
 809
 810         g_dbus_connection_call(handle->dbus_connection,
 811                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 812                         "Search", NULL, NULL,
 813                         G_DBUS_CALL_FLAGS_NONE, TAPI_UNRESTRICTED_TIMEOUT, handle->ca,
 814                         on_response_search_network, evt_cb_data);
 815
 816         return TAPI_API_SUCCESS;
 817 }
 818
 819 EXPORT_API int tel_get_network_selection_mode(struct tapi_handle *handle, tapi_response_cb callback, void *user_data)
 820 {
 821         struct tapi_resp_data *evt_cb_data = NULL;
 822
 823         dbg("Func Entrance");
 824
 825         TAPI_RET_ERR_NUM_IF_FAIL(handle != NULL && callback != NULL, TAPI_API_INVALID_PTR);
 826
 827         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 828
 829         g_dbus_connection_call(handle->dbus_connection,
 830                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 831                         "GetSelectionMode", NULL, NULL,
 832                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 833                         on_response_get_network_selection_mode, evt_cb_data);
 834
 835         return TAPI_API_SUCCESS;
 836 }
 837
 838 EXPORT_API int tel_select_network_automatic(struct tapi_handle *handle, tapi_response_cb callback, void *user_data)
 839 {
 840         struct tapi_resp_data *evt_cb_data = NULL;
 841         GVariant *param;
 842
 843         TAPI_RET_ERR_NUM_IF_FAIL(handle != NULL, TAPI_API_INVALID_PTR);
 844
 845         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 846
 847         param = g_variant_new("(isi)",
 848                         0, /* Automatic */
 849                         "",
 850                         0);
 851
 852         msg("[%s] automatic selection requested", handle->cp_name);
 853
 854         g_dbus_connection_call(handle->dbus_connection,
 855                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 856                         "SetSelectionMode", param, NULL,
 857                         G_DBUS_CALL_FLAGS_NONE, TAPI_UNRESTRICTED_TIMEOUT, handle->ca,
 858                         on_response_default_set, evt_cb_data);
 859
 860         return TAPI_API_SUCCESS;
 861 }
 862
 863 EXPORT_API int tel_select_network_manual(struct tapi_handle *handle, const char *plmn, int type, tapi_response_cb callback, void *user_data)
 864 {
 865         struct tapi_resp_data *evt_cb_data = NULL;
 866         GVariant *param;
 867
 868         TAPI_RET_ERR_NUM_IF_FAIL(handle != NULL && _check_plmn(plmn), TAPI_API_INVALID_PTR);
 869
 870         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 871
 872         param = g_variant_new("(isi)",
 873                         1, /* Manual */
 874                         plmn,
 875                         _convert_systemtype_to_act(type));
 876
 877         msg("[%s] manual selection requested plmn:[%s] type:[%d]",handle->cp_name, plmn?plmn:"", type);
 878
 879         g_dbus_connection_call(handle->dbus_connection,
 880                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 881                         "SetSelectionMode", param, NULL,
 882                         G_DBUS_CALL_FLAGS_NONE, TAPI_UNRESTRICTED_TIMEOUT, handle->ca,
 883                         on_response_select_network, evt_cb_data);
 884
 885         return TAPI_API_SUCCESS;
 886 }
 887
 888 EXPORT_API int tel_set_network_preferred_plmn(
 889                 TapiHandle *handle,
 890                 TelNetworkPreferredPlmnOp_t operation,
 891                 TelNetworkPreferredPlmnInfo_t *info,
 892                 tapi_response_cb callback,
 893                 void *user_data)
 894 {
 895         struct tapi_resp_data *evt_cb_data = NULL;
 896         GVariant *param;
 897         int act = 0;
 898
 899         TAPI_RET_ERR_NUM_IF_FAIL(handle != NULL && info != NULL &&
 900                                                         _check_operation(operation) &&
 901                                                         _check_plmn((const char *)&info->Plmn), TAPI_API_INVALID_PTR);
 902
 903         dbg("Func Entrance");
 904
 905         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 906
 907         switch (info->SystemType) {
 908                 case TAPI_NETWORK_SYSTEM_GSM:
 909                         act = 1;
 910                         break;
 911
 912                 case TAPI_NETWORK_SYSTEM_UMTS:
 913                         act = 4;
 914                         break;
 915
 916                 case TAPI_NETWORK_SYSTEM_GPRS:
 917                         act = 2;
 918                         break;
 919
 920                 case TAPI_NETWORK_SYSTEM_EGPRS:
 921                         act = 3;
 922                         break;
 923
 924                 case TAPI_NETWORK_SYSTEM_GSM_AND_UMTS:
 925                         act = 4;
 926                         break;
 927
 928                 default:
 929                         act = 4;
 930                         break;
 931         }
 932
 933         param = g_variant_new("(iiis)",
 934                         operation,
 935                         info->Index,
 936                         act,
 937                         info->Plmn);
 938
 939         g_dbus_connection_call(handle->dbus_connection,
 940                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 941                         "SetPreferredPlmn", param, NULL,
 942                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 943                         on_response_default_set, evt_cb_data);
 944
 945         return TAPI_API_SUCCESS;
 946 }
 947
 948 EXPORT_API int tel_get_network_preferred_plmn(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 949 {
 950         struct tapi_resp_data *evt_cb_data = NULL;
 951
 952         dbg("Func Entrance");
 953
 954         TAPI_RET_ERR_NUM_IF_FAIL(handle != NULL && callback != NULL, TAPI_API_INVALID_PTR);
 955
 956         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 957
 958         g_dbus_connection_call(handle->dbus_connection,
 959                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 960                         "GetPreferredPlmn", NULL, NULL,
 961                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
 962                         on_response_get_network_preferred_plmn, evt_cb_data);
 963
 964         return TAPI_API_SUCCESS;
 965 }
 966
 967 EXPORT_API int tel_set_network_mode(TapiHandle *handle, int mode, tapi_response_cb callback, void *user_data)
 968 {
 969         struct tapi_resp_data *evt_cb_data = NULL;
 970         GVariant *param;
 971
 972         TAPI_RET_ERR_NUM_IF_FAIL(handle != NULL &&
 973                                                                 _check_network_mode(mode), TAPI_API_INVALID_PTR);
 974
 975         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 976
 977         param = g_variant_new("(i)",
 978                         mode);
 979
 980         msg("[%s] requested mode:[0x%x]", handle->cp_name, mode);
 981
 982         g_dbus_connection_call(handle->dbus_connection,
 983                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 984                         "SetMode", param, NULL,
 985                         G_DBUS_CALL_FLAGS_NONE, TAPI_UNRESTRICTED_TIMEOUT, handle->ca,
 986                         on_response_default_set, evt_cb_data);
 987
 988         return TAPI_API_SUCCESS;
 989 }
 990
 991 EXPORT_API int tel_get_network_mode(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 992 {
 993         struct tapi_resp_data *evt_cb_data = NULL;
 994
 995         TAPI_RET_ERR_NUM_IF_FAIL(handle != NULL && callback != NULL, TAPI_API_INVALID_PTR);
 996
 997         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 998
 999         dbg("[%s] Func Entrance", handle->cp_name);
1000
1001         g_dbus_connection_call(handle->dbus_connection,
1002                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
1003                         "GetMode", NULL, NULL,
1004                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1005                         on_response_get_network_mode, evt_cb_data);
1006
1007         return TAPI_API_SUCCESS;
1008 }
1009
1010 EXPORT_API int tel_cancel_network_manual_search(TapiHandle *handle, tapi_response_cb callback, void *user_data)
1011 {
1012         struct tapi_resp_data *evt_cb_data = NULL;
1013
1014         TAPI_RET_ERR_NUM_IF_FAIL(handle != NULL, TAPI_API_INVALID_PTR);
1015
1016         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1017
1018         msg("[%s] network search cancel requested", handle->cp_name);
1019
1020         g_dbus_connection_call(handle->dbus_connection,
1021                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
1022                         "SearchCancel", NULL, NULL,
1023                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1024                         on_response_default_set, evt_cb_data);
1025
1026         return TAPI_API_SUCCESS;
1027 }
1028
1029 EXPORT_API int tel_get_network_serving(TapiHandle *handle, tapi_response_cb callback, void *user_data)
1030 {
1031         struct tapi_resp_data *evt_cb_data = NULL;
1032
1033         TAPI_RET_ERR_NUM_IF_FAIL(handle != NULL && callback != NULL, TAPI_API_INVALID_PTR);
1034
1035         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1036
1037         dbg("[%s] Func Entrance", handle->cp_name);
1038
1039         g_dbus_connection_call(handle->dbus_connection,
1040                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
1041                         "GetServingNetwork", NULL, NULL,
1042                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1043                         on_response_get_network_serving, evt_cb_data);
1044
1045         return TAPI_API_SUCCESS;
1046 }
1047
1048 EXPORT_API int tel_get_network_neighboring_cell_info(TapiHandle *handle, tapi_response_cb callback, void *user_data)
1049 {
1050         struct tapi_resp_data *evt_cb_data = NULL;
1051
1052         TAPI_RET_ERR_NUM_IF_FAIL(handle != NULL && callback != NULL, TAPI_API_INVALID_PTR);
1053
1054         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1055
1056         dbg("[%s] Func Entrance", handle->cp_name);
1057
1058         g_dbus_connection_call(handle->dbus_connection,
1059                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
1060                         "GetNgbrCellInfo", NULL, NULL,
1061                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1062                         on_response_get_neighboring_cell_info, evt_cb_data);
1063
1064         return TAPI_API_SUCCESS;
1065 }
1066
1067 EXPORT_API int tel_set_network_default_data_subscription(TapiHandle *handle, tapi_response_cb callback, void *user_data)
1068 {
1069         struct tapi_resp_data *evt_cb_data = NULL;
1070
1071         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1072         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
1073
1074         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1075
1076         msg("[%s] Func Entrance", handle->cp_name);
1077
1078         /* DBUS call */
1079         g_dbus_connection_call(handle->dbus_connection,
1080                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
1081                         "SetDefaultDataSubscription", NULL, NULL,
1082                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1083                         on_response_default_set, evt_cb_data);
1084
1085         return TAPI_API_SUCCESS;
1086 }
1087
1088 EXPORT_API int tel_set_network_emergency_callback_mode(TapiHandle *handle, TelNetworkEmergencyCallbackMode_t mode, tapi_response_cb callback, void *user_data)
1089 {
1090         struct tapi_resp_data *evt_cb_data = NULL;
1091         GVariant *param;
1092
1093         TAPI_RET_ERR_NUM_IF_FAIL(handle != NULL &&
1094                                                                 _check_emergency_callback_mode(mode), TAPI_API_INVALID_PTR);
1095
1096         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1097
1098         param = g_variant_new("(i)", mode);
1099
1100         msg("[%s] emergency callback mode :[%d]", handle->cp_name, mode);
1101
1102         g_dbus_connection_call(handle->dbus_connection,
1103                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
1104                         "SetEmergencyCallbackMode", param, NULL,
1105                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1106                         on_response_default_set, evt_cb_data);
1107
1108         return TAPI_API_SUCCESS;
1109 }
1110
1111 EXPORT_API int tel_set_network_roaming_preference(TapiHandle *handle, TelNetworkPrefNetType_t roam_pref, tapi_response_cb callback, void *user_data)
1112 {
1113         struct tapi_resp_data *evt_cb_data = NULL;
1114         GVariant *param;
1115
1116         TAPI_RET_ERR_NUM_IF_FAIL(handle != NULL &&
1117                                                                 _check_roaming_preference(roam_pref), TAPI_API_INVALID_PTR);
1118
1119         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1120
1121         param = g_variant_new("(i)", roam_pref);
1122
1123         msg("[%s] roam_pref:[%d]", handle->cp_name, roam_pref);
1124
1125         g_dbus_connection_call(handle->dbus_connection,
1126                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
1127                         "SetRoamingPreference", param, NULL,
1128                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1129                         on_response_default_set, evt_cb_data);
1130
1131         return TAPI_API_SUCCESS;
1132
1133 }
1134
1135 EXPORT_API int tel_get_network_roaming_preference(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 != NULL && callback != NULL, TAPI_API_INVALID_PTR);
1140
1141         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1142
1143         dbg("[%s] Func Entrance", handle->cp_name);
1144
1145         g_dbus_connection_call(handle->dbus_connection,
1146                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
1147                         "GetRoamingPreference", NULL, NULL,
1148                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1149                         on_response_get_network_roaming_preference, evt_cb_data);
1150
1151         return TAPI_API_SUCCESS;
1152
1153 }
1154
1155 EXPORT_API int tel_get_network_default_data_subscription(TapiHandle *handle, TelNetworkDefaultDataSubs_t *default_subscription)
1156 {
1157         GError *gerr = NULL;
1158         GVariant *sync_gv = NULL;
1159         int subs = 0;
1160         int result = 0;
1161         TapiResult_t ret = TAPI_API_OPERATION_FAILED;
1162
1163         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1164         TAPI_RET_ERR_NUM_IF_FAIL(default_subscription, TAPI_API_INVALID_PTR);
1165
1166         sync_gv = g_dbus_connection_call_sync(handle->dbus_connection,
1167                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
1168                         "GetDefaultDataSubscription", NULL, NULL,
1169                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1170                         &gerr);
1171         if (sync_gv) {
1172                 g_variant_get(sync_gv, "(ii)", &subs, &result);
1173
1174                 if (result == 0)
1175                         *default_subscription = subs;
1176                 else
1177                         *default_subscription = TAPI_NETWORK_DEFAULT_DATA_SUBS_UNKNOWN;
1178
1179                 msg("'default' Data Subscription: [%d]", subs);
1180
1181                 g_variant_unref(sync_gv);
1182                 ret = TAPI_API_SUCCESS;
1183         } else {
1184                 err("Get Data Subscription failed: [%s]", gerr->message);
1185                 g_error_free(gerr);
1186         }
1187
1188         return ret;
1189 }
1190
1191 EXPORT_API int tel_set_network_default_subscription(TapiHandle *handle, tapi_response_cb callback, void *user_data)
1192 {
1193         struct tapi_resp_data *evt_cb_data = NULL;
1194
1195         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1196         TAPI_RET_ERR_NUM_IF_FAIL(callback, TAPI_API_INVALID_PTR);
1197
1198         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1199
1200         dbg("[%s] Set 'default' Subscription (for CS)", handle->cp_name);
1201
1202         /* DBUS call */
1203         g_dbus_connection_call(handle->dbus_connection,
1204                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
1205                         "SetDefaultSubscription", NULL, NULL,
1206                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1207                         on_response_default_set, evt_cb_data);
1208
1209         return TAPI_API_SUCCESS;
1210 }
1211
1212 EXPORT_API int tel_get_network_default_subscription(TapiHandle *handle, TelNetworkDefaultSubs_t *default_subscription)
1213 {
1214         GError *gerr = NULL;
1215         GVariant *sync_gv = NULL;
1216         int subs = 0;
1217         int result = 0;
1218         TapiResult_t ret = TAPI_API_OPERATION_FAILED;
1219
1220         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1221         TAPI_RET_ERR_NUM_IF_FAIL(default_subscription, TAPI_API_INVALID_PTR);
1222
1223         sync_gv = g_dbus_connection_call_sync(handle->dbus_connection,
1224                         DBUS_TELEPHONY_SERVICE, handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
1225                         "GetDefaultSubscription", NULL, NULL,
1226                         G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1227                         &gerr);
1228         if (sync_gv) {
1229                 g_variant_get(sync_gv, "(ii)", &subs, &result);
1230
1231                 if (result == 0)
1232                         *default_subscription = subs;
1233                 else
1234                         *default_subscription = TAPI_NETWORK_DEFAULT_SUBS_UNKNOWN;
1235                 dbg("'default' Subscription (for CS): [%d]", subs);
1236
1237                 g_variant_unref(sync_gv);
1238                 ret = TAPI_API_SUCCESS;
1239         } else {
1240                 err("Get 'default' Subscription (for CS) failed: [%s]", gerr->message);
1241                 g_error_free(gerr);
1242         }
1243
1244         return ret;
1245 }