wearable/src/tapi_network.c

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