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_act_to_systemtype(int act)
  34 {
  35         switch (act) {
  36                 case 0x1:
  37                         return TAPI_NETWORK_SYSTEM_GSM;
  38                         break;
  39
  40                 case 0x2:
  41                         return TAPI_NETWORK_SYSTEM_GPRS;
  42                         break;
  43
  44                 case 0x3:
  45                         return TAPI_NETWORK_SYSTEM_EGPRS;
  46                         break;
  47
  48                 case 0x4:
  49                         return TAPI_NETWORK_SYSTEM_UMTS;
  50                         break;
  51
  52                 case 0x5:
  53                         return TAPI_NETWORK_SYSTEM_GSM_AND_UMTS;
  54                         break;
  55
  56                 case 0x11:
  57                         return TAPI_NETWORK_SYSTEM_IS95A;
  58                         break;
  59
  60                 case 0x12:
  61                         return TAPI_NETWORK_SYSTEM_IS95B;
  62                         break;
  63
  64                 case 0x13:
  65                         return TAPI_NETWORK_SYSTEM_CDMA_1X;
  66                         break;
  67
  68                 case 0x14:
  69                         return TAPI_NETWORK_SYSTEM_EVDO_REV_0;
  70                         break;
  71
  72                 case 0x15:
  73                         return TAPI_NETWORK_SYSTEM_1X_EVDO_REV_0_HYBRID;
  74                         break;
  75
  76                 case 0x16:
  77                         return TAPI_NETWORK_SYSTEM_EVDO_REV_A;
  78                         break;
  79
  80                 case 0x17:
  81                         return TAPI_NETWORK_SYSTEM_1X_EVDO_REV_A_HYBRID;
  82                         break;
  83
  84                 case 0x18:
  85                         return TAPI_NETWORK_SYSTEM_EVDV;
  86                         break;
  87
  88                 default:
  89                         break;
  90         }
  91
  92         return TAPI_NETWORK_SYSTEM_NO_SRV;
  93 }
  94
  95 static void on_response_search_network(GObject *source_object, GAsyncResult *res, gpointer user_data)
  96 {
  97         GError *error = NULL;
  98         GDBusConnection *conn = NULL;
  99         struct tapi_resp_data *evt_cb_data = user_data;
 100         int result = -1;
 101         int i;
 102
 103         TelNetworkPlmnList_t list;
 104
 105         GVariant *dbus_result = NULL;
 106         GVariant *value = NULL;
 107         GVariantIter *iter = NULL;
 108         GVariantIter *iter_row = NULL;
 109         const gchar *key = NULL;
 110
 111         memset(&list, 0, sizeof(TelNetworkPlmnList_t));
 112
 113         conn = G_DBUS_CONNECTION (source_object);
 114
 115         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 116         if (!dbus_result) {
 117                 if (evt_cb_data->cb_fn) {
 118                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 119                 }
 120
 121                 free(evt_cb_data);
 122                 return;
 123         }
 124
 125         g_variant_get (dbus_result, "(aa{sv}i)", &iter, &result);
 126
 127         list.networks_count = g_variant_iter_n_children(iter);
 128
 129         i = 0;
 130         while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
 131                 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
 132                         if (!g_strcmp0(key, "plmn")) {
 133                                 list.network_list[i].plmn_id = atoi(g_variant_get_string(value, NULL));
 134                         }
 135                         if (!g_strcmp0(key, "act")) {
 136                                 list.network_list[i].access_technology = _convert_act_to_systemtype(g_variant_get_int32(value));
 137                         }
 138                         if (!g_strcmp0(key, "type")) {
 139                                 list.network_list[i].type_of_plmn = g_variant_get_int32(value);
 140                         }
 141                         if (!g_strcmp0(key, "name")) {
 142                                 strncpy(list.network_list[i].network_name, g_variant_get_string(value, NULL), 40);
 143                         }
 144                 }
 145                 i++;
 146                 g_variant_iter_free(iter_row);
 147         }
 148         g_variant_iter_free(iter);
 149
 150         if (evt_cb_data->cb_fn) {
 151                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &list, evt_cb_data->user_data);
 152         }
 153
 154         free(evt_cb_data);
 155 }
 156
 157 static void on_response_get_network_selection_mode(GObject *source_object, GAsyncResult *res, gpointer user_data)
 158 {
 159         GError *error = NULL;
 160         GDBusConnection *conn = NULL;
 161         struct tapi_resp_data *evt_cb_data = user_data;
 162         int result = -1;
 163
 164         GVariant *dbus_result;
 165         int mode = 0;
 166
 167         conn = G_DBUS_CONNECTION (source_object);
 168         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 169
 170         g_variant_get (dbus_result, "(ii)", &mode, &result);
 171
 172         if (evt_cb_data->cb_fn) {
 173                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &mode, evt_cb_data->user_data);
 174         }
 175
 176         free(evt_cb_data);
 177 }
 178
 179 static void on_response_default_set(GObject *source_object, GAsyncResult *res, gpointer user_data)
 180 {
 181         GError *error = NULL;
 182         GDBusConnection *conn = NULL;
 183         struct tapi_resp_data *evt_cb_data = user_data;
 184         int result = -1;
 185
 186         GVariant *dbus_result;
 187
 188         conn = G_DBUS_CONNECTION (source_object);
 189         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 190
 191         g_variant_get (dbus_result, "(i)", &result);
 192
 193         if (evt_cb_data->cb_fn) {
 194                 evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
 195         }
 196
 197         free(evt_cb_data);
 198 }
 199
 200 static void on_response_get_network_preferred_plmn(GDBusConnection *conn, GAsyncResult *res, gpointer user_data)
 201 {
 202         GError *error = NULL;
 203         struct tapi_resp_data *evt_cb_data = user_data;
 204         int result = -1;
 205         int i;
 206
 207         TelNetworkPreferredPlmnList_t list;
 208
 209         GVariant *dbus_result = NULL;
 210         GVariant *value = NULL;
 211         GVariantIter *iter = NULL;
 212         GVariantIter *iter_row = NULL;
 213         const gchar *key = NULL;
 214
 215         memset(&list, 0, sizeof(TelNetworkPreferredPlmnList_t));
 216
 217         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 218
 219         dbg("dbus_result = %p", dbus_result);
 220         dbg("res = %p", res);
 221         dbg("conn = %p", conn);
 222
 223         if (!dbus_result) {
 224                 dbg("error");
 225                 if (evt_cb_data->cb_fn) {
 226                         evt_cb_data->cb_fn(evt_cb_data->handle, result, &list, evt_cb_data->user_data);
 227                 }
 228
 229                 free(evt_cb_data);
 230                 return;
 231         }
 232
 233         g_variant_get (dbus_result, "(aa{sv}i)", &iter, &result);
 234
 235         list.NumOfPrefPlmns = g_variant_iter_n_children(iter);
 236
 237         if (list.NumOfPrefPlmns == 0) {
 238                 dbg("num_of_.. = 0");
 239                 if (evt_cb_data->cb_fn) {
 240                         evt_cb_data->cb_fn(evt_cb_data->handle, result, &list, evt_cb_data->user_data);
 241                 }
 242
 243                 free(evt_cb_data);
 244                 return;
 245         }
 246
 247         i = 0;
 248         while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
 249                 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
 250                         if (!g_strcmp0(key, "plmn")) {
 251                                 strncpy(list.PrefPlmnRecord[i].Plmn, g_variant_get_string(value, NULL), 6);
 252                         }
 253                         if (!g_strcmp0(key, "act")) {
 254                                 list.PrefPlmnRecord[i].SystemType = _convert_act_to_systemtype(g_variant_get_int32(value));
 255                         }
 256                         if (!g_strcmp0(key, "ef_index")) {
 257                                 list.PrefPlmnRecord[i].Index = g_variant_get_int32(value);
 258                         }
 259                         if (!g_strcmp0(key, "name")) {
 260                                 strncpy(list.PrefPlmnRecord[i].network_name, g_variant_get_string(value, NULL), 40);
 261                         }
 262                 }
 263                 i++;
 264                 g_variant_iter_free(iter_row);
 265         }
 266         g_variant_iter_free(iter);
 267
 268         if (evt_cb_data->cb_fn) {
 269                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &list, evt_cb_data->user_data);
 270         }
 271
 272         free(evt_cb_data);
 273 }
 274
 275 static void on_response_get_network_band(GObject *source_object, GAsyncResult *res, gpointer user_data)
 276 {
 277         GError *error = NULL;
 278         GDBusConnection *conn = NULL;
 279         struct tapi_resp_data *evt_cb_data = user_data;
 280         int result = -1;
 281
 282         GVariant *dbus_result;
 283         int band = 0;
 284         int mode = 0;
 285
 286         conn = G_DBUS_CONNECTION (source_object);
 287         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 288
 289         g_variant_get (dbus_result, "(iii)", &band, &mode, &result);
 290
 291         if (evt_cb_data->cb_fn) {
 292                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &band, evt_cb_data->user_data);
 293         }
 294
 295         free(evt_cb_data);
 296 }
 297
 298 static void on_response_get_network_mode(GObject *source_object, GAsyncResult *res, gpointer user_data)
 299 {
 300         GError *error = NULL;
 301         GDBusConnection *conn = NULL;
 302         struct tapi_resp_data *evt_cb_data = user_data;
 303         int result = -1;
 304
 305         GVariant *dbus_result;
 306         int mode = 0;
 307
 308         conn = G_DBUS_CONNECTION (source_object);
 309         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 310
 311         g_variant_get (dbus_result, "(ii)", &mode, &result);
 312
 313         if (evt_cb_data->cb_fn) {
 314                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &mode, evt_cb_data->user_data);
 315         }
 316
 317         free(evt_cb_data);
 318 }
 319
 320 static void on_response_get_network_service_domain(GObject *source_object, GAsyncResult *res, gpointer user_data)
 321 {
 322         GError *error = NULL;
 323         GDBusConnection *conn = NULL;
 324         struct tapi_resp_data *evt_cb_data = user_data;
 325         int result = -1;
 326
 327         GVariant *dbus_result;
 328         int domain = 0;
 329
 330         conn = G_DBUS_CONNECTION (source_object);
 331         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 332
 333         g_variant_get (dbus_result, "(ii)", &domain, &result);
 334
 335         if (evt_cb_data->cb_fn) {
 336                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &domain, evt_cb_data->user_data);
 337         }
 338
 339         free(evt_cb_data);
 340 }
 341
 342 static void on_response_get_network_serving(GObject *source_object, GAsyncResult *res, gpointer user_data)
 343 {
 344         GError *error = NULL;
 345         GDBusConnection *conn = NULL;
 346         struct tapi_resp_data *evt_cb_data = user_data;
 347         int result = -1;
 348
 349         TelNetworkServing_t data;
 350
 351         GVariant *dbus_result;
 352         char *plmn;
 353
 354         memset(&data, 0, sizeof(TelNetworkServing_t));
 355
 356         conn = G_DBUS_CONNECTION (source_object);
 357         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 358
 359         g_variant_get (dbus_result, "(isii)",
 360                         &data.act,
 361                         &plmn,
 362                         &data.lac,
 363                         &result);
 364
 365         if (plmn) {
 366                 snprintf(data.plmn, 7, "%s", plmn);
 367                 free(plmn);
 368         }
 369
 370         if (evt_cb_data->cb_fn) {
 371                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
 372         }
 373
 374         free(evt_cb_data);
 375 }
 376
 377 EXPORT_API int tel_search_network(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 378 {
 379         struct tapi_resp_data *evt_cb_data = NULL;
 380
 381         dbg("Func Entrance");
 382
 383         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 384
 385         g_dbus_connection_call(handle->dbus_connection,
 386                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 387                         "Search", NULL, NULL,
 388                         G_DBUS_CALL_FLAGS_NONE, 180000, NULL,
 389                         on_response_search_network, evt_cb_data);
 390
 391         return TAPI_API_SUCCESS;
 392 }
 393
 394 EXPORT_API int tel_get_network_selection_mode(struct tapi_handle *handle, tapi_response_cb callback, void *user_data)
 395 {
 396         struct tapi_resp_data *evt_cb_data = NULL;
 397
 398         dbg("Func Entrance");
 399
 400         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 401
 402         g_dbus_connection_call(handle->dbus_connection,
 403                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 404                         "GetSelectionMode", NULL, NULL,
 405                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
 406                         on_response_get_network_selection_mode, evt_cb_data);
 407
 408         return TAPI_API_SUCCESS;
 409 }
 410
 411 EXPORT_API int tel_select_network_automatic(struct tapi_handle *handle, tapi_response_cb callback, void *user_data)
 412 {
 413         struct tapi_resp_data *evt_cb_data = NULL;
 414         GVariant *param;
 415
 416         dbg("Func Entrance");
 417
 418         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 419
 420         param = g_variant_new("(isi)",
 421                         0, /* Automatic */
 422                         "",
 423                         0);
 424
 425         g_dbus_connection_call(handle->dbus_connection,
 426                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 427                         "SetSelectionMode", param, NULL,
 428                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
 429                         on_response_default_set, evt_cb_data);
 430
 431         return TAPI_API_SUCCESS;
 432 }
 433
 434 EXPORT_API int tel_select_network_manual(struct tapi_handle *handle, const char *plmn, int act, tapi_response_cb callback, void *user_data)
 435 {
 436         struct tapi_resp_data *evt_cb_data = NULL;
 437         GVariant *param;
 438
 439         dbg("Func Entrance");
 440
 441         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 442
 443         param = g_variant_new("(isi)",
 444                         1, /* Manual */
 445                         plmn,
 446                         act);
 447
 448         g_dbus_connection_call(handle->dbus_connection,
 449                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 450                         "SetSelectionMode", param, NULL,
 451                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
 452                         on_response_default_set, evt_cb_data);
 453
 454         return TAPI_API_SUCCESS;
 455 }
 456
 457 EXPORT_API int tel_set_network_preferred_plmn(
 458                 TapiHandle *handle,
 459                 TelNetworkPreferredPlmnOp_t operation,
 460                 TelNetworkPreferredPlmnInfo_t *info,
 461                 tapi_response_cb callback,
 462                 void *user_data)
 463 {
 464         struct tapi_resp_data *evt_cb_data = NULL;
 465         GVariant *param;
 466         int act = 0;
 467
 468         dbg("Func Entrance");
 469
 470         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 471
 472         switch (info->SystemType) {
 473                 case TAPI_NETWORK_SYSTEM_GSM:
 474                         act = 1;
 475                         break;
 476
 477                 case TAPI_NETWORK_SYSTEM_UMTS:
 478                         act = 4;
 479                         break;
 480
 481                 case TAPI_NETWORK_SYSTEM_GPRS:
 482                         act = 2;
 483                         break;
 484
 485                 case TAPI_NETWORK_SYSTEM_EGPRS:
 486                         act = 3;
 487                         break;
 488
 489                 case TAPI_NETWORK_SYSTEM_GSM_AND_UMTS:
 490                         act = 4;
 491                         break;
 492
 493                 default:
 494                         act = 4;
 495                         break;
 496         }
 497
 498         param = g_variant_new("(iiis)",
 499                         operation,
 500                         info->Index,
 501                         act,
 502                         info->Plmn);
 503
 504         g_dbus_connection_call(handle->dbus_connection,
 505                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 506                         "SetPreferredPlmn", param, NULL,
 507                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
 508                         on_response_default_set, evt_cb_data);
 509
 510         return TAPI_API_SUCCESS;
 511 }
 512
 513 EXPORT_API int tel_get_network_preferred_plmn(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 514 {
 515         struct tapi_resp_data *evt_cb_data = NULL;
 516
 517         dbg("Func Entrance");
 518
 519         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 520
 521         g_dbus_connection_call(handle->dbus_connection,
 522                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 523                         "GetPreferredPlmn", NULL, NULL,
 524                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
 525                         (GAsyncReadyCallback) on_response_get_network_preferred_plmn, evt_cb_data);
 526
 527         return TAPI_API_SUCCESS;
 528 }
 529
 530 EXPORT_API int tel_set_network_band(TapiHandle *handle, TelNetworkBandPreferred_t mode, TelNetworkBand_t band, tapi_response_cb callback, void *user_data)
 531 {
 532         struct tapi_resp_data *evt_cb_data = NULL;
 533         GVariant *param;
 534
 535         dbg("Func Entrance");
 536
 537         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 538
 539         param = g_variant_new("(ii)",
 540                         band,
 541                         mode);
 542
 543         g_dbus_connection_call(handle->dbus_connection,
 544                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 545                         "SetBand", param, NULL,
 546                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
 547                         on_response_default_set, evt_cb_data);
 548
 549         return TAPI_API_SUCCESS;
 550 }
 551
 552 EXPORT_API int tel_get_network_band(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 553 {
 554         struct tapi_resp_data *evt_cb_data = NULL;
 555
 556         dbg("Func Entrance");
 557
 558         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 559
 560         g_dbus_connection_call(handle->dbus_connection,
 561                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 562                         "GetBand", NULL, NULL,
 563                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
 564                         on_response_get_network_band, evt_cb_data);
 565
 566         return TAPI_API_SUCCESS;
 567 }
 568
 569 EXPORT_API int tel_set_network_mode(TapiHandle *handle, int mode, tapi_response_cb callback, void *user_data)
 570 {
 571         struct tapi_resp_data *evt_cb_data = NULL;
 572         GVariant *param;
 573
 574         dbg("Func Entrance");
 575
 576         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 577
 578         param = g_variant_new("(i)",
 579                         mode);
 580
 581         g_dbus_connection_call(handle->dbus_connection,
 582                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 583                         "SetMode", param, NULL,
 584                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
 585                         on_response_default_set, evt_cb_data);
 586
 587         return TAPI_API_SUCCESS;
 588 }
 589
 590 EXPORT_API int tel_get_network_mode(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 591 {
 592         struct tapi_resp_data *evt_cb_data = NULL;
 593
 594         dbg("Func Entrance");
 595
 596         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 597
 598         g_dbus_connection_call(handle->dbus_connection,
 599                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 600                         "GetMode", NULL, NULL,
 601                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
 602                         on_response_get_network_mode, evt_cb_data);
 603
 604         return TAPI_API_SUCCESS;
 605 }
 606
 607 EXPORT_API int tel_set_network_service_domain(TapiHandle *handle, TelNetworkServiceDomain_t domain, tapi_response_cb callback, void *user_data)
 608 {
 609         struct tapi_resp_data *evt_cb_data = NULL;
 610         GVariant *param;
 611
 612         dbg("Func Entrance");
 613
 614         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 615
 616         param = g_variant_new("(i)", domain);
 617
 618         g_dbus_connection_call(handle->dbus_connection,
 619                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 620                         "SetServiceDomain", param, NULL,
 621                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
 622                         on_response_default_set, evt_cb_data);
 623
 624         return TAPI_API_SUCCESS;
 625 }
 626
 627 EXPORT_API int tel_get_network_service_domain(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 628 {
 629         struct tapi_resp_data *evt_cb_data = NULL;
 630
 631         dbg("Func Entrance");
 632
 633         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 634
 635         g_dbus_connection_call(handle->dbus_connection,
 636                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 637                         "GetServiceDomain", NULL, NULL,
 638                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
 639                         on_response_get_network_service_domain, evt_cb_data);
 640
 641         return TAPI_API_SUCCESS;
 642 }
 643
 644 EXPORT_API int tel_cancel_network_manual_search(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 645 {
 646         struct tapi_resp_data *evt_cb_data = NULL;
 647
 648         dbg("Func Entrance");
 649
 650         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 651
 652         g_dbus_connection_call(handle->dbus_connection,
 653                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 654                         "SearchCancel", NULL, NULL,
 655                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
 656                         on_response_default_set, evt_cb_data);
 657
 658         return TAPI_API_SUCCESS;
 659 }
 660
 661 EXPORT_API int tel_get_network_serving(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 662 {
 663         struct tapi_resp_data *evt_cb_data = NULL;
 664
 665         dbg("Func Entrance");
 666
 667         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 668
 669         g_dbus_connection_call(handle->dbus_connection,
 670                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 671                         "GetServingNetwork", NULL, NULL,
 672                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
 673                         on_response_get_network_serving, evt_cb_data);
 674
 675         return TAPI_API_SUCCESS;
 676 }