mobile/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_response_search_network(GObject *source_object, GAsyncResult *res, gpointer user_data)
 169 {
 170         GError *error = NULL;
 171         GDBusConnection *conn = NULL;
 172         struct tapi_resp_data *evt_cb_data = user_data;
 173         int result = -1;
 174         int i;
 175
 176         TelNetworkPlmnList_t list;
 177
 178         GVariant *dbus_result = NULL;
 179         GVariant *value = NULL;
 180         GVariantIter *iter = NULL;
 181         GVariantIter *iter_row = NULL;
 182         const gchar *key = NULL;
 183
 184         memset(&list, 0, sizeof(TelNetworkPlmnList_t));
 185
 186         conn = G_DBUS_CONNECTION (source_object);
 187
 188         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 189         CHECK_DEINIT(error);
 190
 191         if (!dbus_result) {
 192                 if (evt_cb_data->cb_fn) {
 193                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 194                 }
 195
 196                 if (error)
 197                         g_error_free(error);
 198
 199                 free(evt_cb_data);
 200                 return;
 201         }
 202
 203         g_variant_get (dbus_result, "(aa{sv}i)", &iter, &result);
 204
 205         list.networks_count = g_variant_iter_n_children(iter);
 206
 207         i = 0;
 208         while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
 209                 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
 210                         if (!g_strcmp0(key, "plmn")) {
 211                                 list.network_list[i].plmn_id = atoi(g_variant_get_string(value, NULL));
 212                                 strncpy(list.network_list[i].plmn, g_variant_get_string(value, NULL), TAPI_NETWORK_PLMN_LEN_MAX);
 213                         }
 214                         if (!g_strcmp0(key, "act")) {
 215                                 list.network_list[i].access_technology = _convert_act_to_systemtype(g_variant_get_int32(value));
 216                         }
 217                         if (!g_strcmp0(key, "type")) {
 218                                 list.network_list[i].type_of_plmn = g_variant_get_int32(value);
 219                         }
 220                         if (!g_strcmp0(key, "name")) {
 221                                 strncpy(list.network_list[i].network_name, g_variant_get_string(value, NULL), 40);
 222                         }
 223                 }
 224                 i++;
 225                 g_variant_iter_free(iter_row);
 226         }
 227         g_variant_iter_free(iter);
 228
 229         if (evt_cb_data->cb_fn) {
 230                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &list, evt_cb_data->user_data);
 231         }
 232
 233         free(evt_cb_data);
 234 }
 235
 236 static void on_response_get_network_selection_mode(GObject *source_object, GAsyncResult *res, gpointer user_data)
 237 {
 238         GError *error = NULL;
 239         GDBusConnection *conn = NULL;
 240         struct tapi_resp_data *evt_cb_data = user_data;
 241         int result = -1;
 242
 243         GVariant *dbus_result;
 244         int mode = 0;
 245
 246         conn = G_DBUS_CONNECTION (source_object);
 247         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 248         CHECK_DEINIT(error);
 249
 250         if (!dbus_result) {
 251                 if (evt_cb_data->cb_fn) {
 252                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 253                 }
 254
 255                 if (error)
 256                         g_error_free(error);
 257
 258                 free(evt_cb_data);
 259                 return;
 260         }
 261
 262         g_variant_get (dbus_result, "(ii)", &mode, &result);
 263
 264         if (evt_cb_data->cb_fn) {
 265                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &mode, evt_cb_data->user_data);
 266         }
 267
 268         free(evt_cb_data);
 269 }
 270
 271 static void on_response_default_set(GObject *source_object, GAsyncResult *res, gpointer user_data)
 272 {
 273         GError *error = NULL;
 274         GDBusConnection *conn = NULL;
 275         struct tapi_resp_data *evt_cb_data = user_data;
 276         int result = -1;
 277
 278         GVariant *dbus_result;
 279
 280         conn = G_DBUS_CONNECTION (source_object);
 281         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 282         CHECK_DEINIT(error);
 283
 284         if (!dbus_result) {
 285                 if (evt_cb_data->cb_fn) {
 286                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 287                 }
 288
 289                 if (error)
 290                         g_error_free(error);
 291
 292                 free(evt_cb_data);
 293                 return;
 294         }
 295
 296
 297         g_variant_get (dbus_result, "(i)", &result);
 298
 299         if (evt_cb_data->cb_fn) {
 300                 evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
 301         }
 302
 303         free(evt_cb_data);
 304 }
 305
 306 static void on_response_get_network_preferred_plmn(GDBusConnection *conn, GAsyncResult *res, gpointer user_data)
 307 {
 308         GError *error = NULL;
 309         struct tapi_resp_data *evt_cb_data = user_data;
 310         int result = -1;
 311         int i;
 312
 313         TelNetworkPreferredPlmnList_t list;
 314
 315         GVariant *dbus_result = NULL;
 316         GVariant *value = NULL;
 317         GVariantIter *iter = NULL;
 318         GVariantIter *iter_row = NULL;
 319         const gchar *key = NULL;
 320
 321         memset(&list, 0, sizeof(TelNetworkPreferredPlmnList_t));
 322
 323         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 324         CHECK_DEINIT(error);
 325
 326         if (!dbus_result) {
 327                 if (evt_cb_data->cb_fn) {
 328                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, &list, evt_cb_data->user_data);
 329                 }
 330
 331                 if (error)
 332                         g_error_free(error);
 333
 334                 free(evt_cb_data);
 335                 return;
 336         }
 337
 338         g_variant_get (dbus_result, "(aa{sv}i)", &iter, &result);
 339
 340         list.NumOfPrefPlmns = g_variant_iter_n_children(iter);
 341
 342         if (list.NumOfPrefPlmns == 0) {
 343                 dbg("num_of_.. = 0");
 344                 if (evt_cb_data->cb_fn) {
 345                         evt_cb_data->cb_fn(evt_cb_data->handle, result, &list, evt_cb_data->user_data);
 346                 }
 347
 348                 free(evt_cb_data);
 349                 return;
 350         }
 351
 352         i = 0;
 353         while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
 354                 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
 355                         if (!g_strcmp0(key, "plmn")) {
 356                                 strncpy(list.PrefPlmnRecord[i].Plmn, g_variant_get_string(value, NULL), 6);
 357                         }
 358                         if (!g_strcmp0(key, "act")) {
 359                                 list.PrefPlmnRecord[i].SystemType = _convert_act_to_systemtype(g_variant_get_int32(value));
 360                         }
 361                         if (!g_strcmp0(key, "index")) {
 362                                 list.PrefPlmnRecord[i].Index = g_variant_get_int32(value);
 363                         }
 364                         if (!g_strcmp0(key, "name")) {
 365                                 strncpy(list.PrefPlmnRecord[i].network_name, g_variant_get_string(value, NULL), 40);
 366                         }
 367                 }
 368                 i++;
 369                 g_variant_iter_free(iter_row);
 370         }
 371         g_variant_iter_free(iter);
 372
 373         if (evt_cb_data->cb_fn) {
 374                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &list, evt_cb_data->user_data);
 375         }
 376
 377         free(evt_cb_data);
 378 }
 379
 380 static void on_response_get_network_band(GObject *source_object, GAsyncResult *res, gpointer user_data)
 381 {
 382         GError *error = NULL;
 383         GDBusConnection *conn = NULL;
 384         struct tapi_resp_data *evt_cb_data = user_data;
 385         int result = -1;
 386
 387         GVariant *dbus_result;
 388         int band = 0;
 389         int mode = 0;
 390
 391         conn = G_DBUS_CONNECTION (source_object);
 392         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 393         CHECK_DEINIT(error);
 394
 395         if (!dbus_result) {
 396                 if (evt_cb_data->cb_fn) {
 397                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 398                 }
 399
 400                 if (error)
 401                         g_error_free(error);
 402
 403                 free(evt_cb_data);
 404                 return;
 405         }
 406
 407         g_variant_get (dbus_result, "(iii)", &band, &mode, &result);
 408
 409         if (evt_cb_data->cb_fn) {
 410                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &band, evt_cb_data->user_data);
 411         }
 412
 413         free(evt_cb_data);
 414 }
 415
 416 static void on_response_get_network_mode(GObject *source_object, GAsyncResult *res, gpointer user_data)
 417 {
 418         GError *error = NULL;
 419         GDBusConnection *conn = NULL;
 420         struct tapi_resp_data *evt_cb_data = user_data;
 421         int result = -1;
 422
 423         GVariant *dbus_result;
 424         int mode = 0;
 425
 426         conn = G_DBUS_CONNECTION (source_object);
 427         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 428         CHECK_DEINIT(error);
 429
 430         if (!dbus_result) {
 431                 if (evt_cb_data->cb_fn) {
 432                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 433                 }
 434
 435                 if (error)
 436                         g_error_free(error);
 437
 438                 free(evt_cb_data);
 439                 return;
 440         }
 441
 442         g_variant_get (dbus_result, "(ii)", &mode, &result);
 443
 444         if (evt_cb_data->cb_fn) {
 445                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &mode, evt_cb_data->user_data);
 446         }
 447
 448         free(evt_cb_data);
 449 }
 450
 451 static void on_response_get_network_service_domain(GObject *source_object, GAsyncResult *res, gpointer user_data)
 452 {
 453         GError *error = NULL;
 454         GDBusConnection *conn = NULL;
 455         struct tapi_resp_data *evt_cb_data = user_data;
 456         int result = -1;
 457
 458         GVariant *dbus_result;
 459         int domain = 0;
 460
 461         conn = G_DBUS_CONNECTION (source_object);
 462         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 463         CHECK_DEINIT(error);
 464
 465         if (!dbus_result) {
 466                 if (evt_cb_data->cb_fn) {
 467                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 468                 }
 469
 470                 if (error)
 471                         g_error_free(error);
 472
 473                 free(evt_cb_data);
 474                 return;
 475         }
 476
 477         g_variant_get (dbus_result, "(ii)", &domain, &result);
 478
 479         if (evt_cb_data->cb_fn) {
 480                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &domain, evt_cb_data->user_data);
 481         }
 482
 483         free(evt_cb_data);
 484 }
 485
 486 static void on_response_get_network_serving(GObject *source_object, GAsyncResult *res, gpointer user_data)
 487 {
 488         GError *error = NULL;
 489         GDBusConnection *conn = NULL;
 490         struct tapi_resp_data *evt_cb_data = user_data;
 491         int result = -1;
 492
 493         TelNetworkServing_t data;
 494
 495         GVariant *dbus_result;
 496         char *plmn;
 497
 498         memset(&data, 0, sizeof(TelNetworkServing_t));
 499
 500         conn = G_DBUS_CONNECTION (source_object);
 501         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 502         CHECK_DEINIT(error);
 503
 504         if (!dbus_result) {
 505                 if (evt_cb_data->cb_fn) {
 506                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 507                 }
 508
 509                 if (error)
 510                         g_error_free(error);
 511
 512                 free(evt_cb_data);
 513                 return;
 514         }
 515
 516         g_variant_get (dbus_result, "(isii)",
 517                         &data.act,
 518                         &plmn,
 519                         &data.lac,
 520                         &result);
 521
 522         data.act = _convert_act_to_systemtype(data.act);
 523
 524         if (plmn) {
 525                 snprintf(data.plmn, 7, "%s", plmn);
 526                 free(plmn);
 527         }
 528
 529         if (evt_cb_data->cb_fn) {
 530                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
 531         }
 532
 533         free(evt_cb_data);
 534 }
 535
 536 static void on_response_get_neighboring_cell_info(GObject *source_object, GAsyncResult *res, gpointer user_data)
 537 {
 538         GError *error = NULL;
 539         GDBusConnection *conn = NULL;
 540         struct tapi_resp_data *evt_cb_data = user_data;
 541         int result = -1;
 542         int geran_index=0, umts_index=0;
 543
 544         TelNetworkNeighboringCellInfo_t list;
 545
 546         GVariant *dbus_result = NULL;
 547         GVariant *value = NULL;
 548         GVariantIter *iter = NULL;
 549         GVariantIter *iter_row = NULL;
 550         const gchar *key = NULL;
 551         gint v0, v1,v2,v3,v4;
 552
 553         memset(&list, 0, sizeof(TelNetworkNeighboringCellInfo_t));
 554
 555         dbg("enter");
 556         conn = G_DBUS_CONNECTION (source_object);
 557
 558         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 559         CHECK_DEINIT(error);
 560
 561         if (!dbus_result) {
 562                 if (evt_cb_data->cb_fn) {
 563                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 564                 }
 565
 566                 if (error)
 567                         g_error_free(error);
 568
 569                 free(evt_cb_data);
 570                 return;
 571         }
 572
 573         g_variant_get (dbus_result, "(aa{sv}i)", &iter, &result);
 574
 575         while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
 576                 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
 577                         g_variant_get(value, "(iiiii)", &v0,&v1,&v2,&v3,&v4);
 578                         if (!g_strcmp0(key, "geran")) {
 579                                 list.geran_list[geran_index].cell_id    = v0;
 580                                 list.geran_list[geran_index].lac                = v1;
 581                                 list.geran_list[geran_index].bcch               = v2;
 582                                 list.geran_list[geran_index].bsic               = v3;
 583                                 list.geran_list[geran_index].rxlev              = v4;
 584                                 geran_index++;
 585                         }
 586                         else if (!g_strcmp0(key, "umts")) {
 587                                 list.umts_list[umts_index].cell_id      = v0;
 588                                 list.umts_list[umts_index].lac          = v1;
 589                                 list.umts_list[umts_index].arfcn        = v2;
 590                                 list.umts_list[umts_index].psc          = v3;
 591                                 list.umts_list[umts_index].rscp         = v4;
 592                                 umts_index++;
 593                         }
 594                 }
 595                 g_variant_iter_free(iter_row);
 596         }
 597         g_variant_iter_free(iter);
 598
 599         list.geran_list_count = geran_index;
 600         list.umts_list_count = umts_index;
 601         dbg("geran_list_count=%d, umts_list_count=%d", geran_index, umts_index);
 602
 603         if (evt_cb_data->cb_fn) {
 604                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &list, evt_cb_data->user_data);
 605         }
 606
 607         free(evt_cb_data);
 608 }
 609
 610 EXPORT_API int tel_search_network(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 611 {
 612         struct tapi_resp_data *evt_cb_data = NULL;
 613
 614         dbg("Func Entrance");
 615
 616         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 617
 618         g_dbus_connection_call(handle->dbus_connection,
 619                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 620                         "Search", NULL, NULL,
 621                         G_DBUS_CALL_FLAGS_NONE, 180000, handle->ca,
 622                         on_response_search_network, evt_cb_data);
 623
 624         return TAPI_API_SUCCESS;
 625 }
 626
 627 EXPORT_API int tel_get_network_selection_mode(struct tapi_handle *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                         "GetSelectionMode", NULL, NULL,
 638                         G_DBUS_CALL_FLAGS_NONE, -1, handle->ca,
 639                         on_response_get_network_selection_mode, evt_cb_data);
 640
 641         return TAPI_API_SUCCESS;
 642 }
 643
 644 EXPORT_API int tel_select_network_automatic(struct tapi_handle *handle, tapi_response_cb callback, void *user_data)
 645 {
 646         struct tapi_resp_data *evt_cb_data = NULL;
 647         GVariant *param;
 648
 649         dbg("Func Entrance");
 650
 651         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 652
 653         param = g_variant_new("(isi)",
 654                         0, /* Automatic */
 655                         "",
 656                         0);
 657
 658         g_dbus_connection_call(handle->dbus_connection,
 659                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 660                         "SetSelectionMode", param, NULL,
 661                         G_DBUS_CALL_FLAGS_NONE, 180000, handle->ca,
 662                         on_response_default_set, evt_cb_data);
 663
 664         return TAPI_API_SUCCESS;
 665 }
 666
 667 EXPORT_API int tel_select_network_manual(struct tapi_handle *handle, const char *plmn, int type, tapi_response_cb callback, void *user_data)
 668 {
 669         struct tapi_resp_data *evt_cb_data = NULL;
 670         GVariant *param;
 671
 672         dbg("Func Entrance");
 673
 674         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 675
 676         param = g_variant_new("(isi)",
 677                         1, /* Manual */
 678                         plmn,
 679                         _convert_systemtype_to_act(type));
 680
 681         g_dbus_connection_call(handle->dbus_connection,
 682                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 683                         "SetSelectionMode", param, NULL,
 684                         G_DBUS_CALL_FLAGS_NONE, 180000, handle->ca,
 685                         on_response_default_set, evt_cb_data);
 686
 687         return TAPI_API_SUCCESS;
 688 }
 689
 690 EXPORT_API int tel_set_network_preferred_plmn(
 691                 TapiHandle *handle,
 692                 TelNetworkPreferredPlmnOp_t operation,
 693                 TelNetworkPreferredPlmnInfo_t *info,
 694                 tapi_response_cb callback,
 695                 void *user_data)
 696 {
 697         struct tapi_resp_data *evt_cb_data = NULL;
 698         GVariant *param;
 699         int act = 0;
 700
 701         dbg("Func Entrance");
 702
 703         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 704
 705         switch (info->SystemType) {
 706                 case TAPI_NETWORK_SYSTEM_GSM:
 707                         act = 1;
 708                         break;
 709
 710                 case TAPI_NETWORK_SYSTEM_UMTS:
 711                         act = 4;
 712                         break;
 713
 714                 case TAPI_NETWORK_SYSTEM_GPRS:
 715                         act = 2;
 716                         break;
 717
 718                 case TAPI_NETWORK_SYSTEM_EGPRS:
 719                         act = 3;
 720                         break;
 721
 722                 case TAPI_NETWORK_SYSTEM_GSM_AND_UMTS:
 723                         act = 4;
 724                         break;
 725
 726                 default:
 727                         act = 4;
 728                         break;
 729         }
 730
 731         param = g_variant_new("(iiis)",
 732                         operation,
 733                         info->Index,
 734                         act,
 735                         info->Plmn);
 736
 737         g_dbus_connection_call(handle->dbus_connection,
 738                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 739                         "SetPreferredPlmn", param, NULL,
 740                         G_DBUS_CALL_FLAGS_NONE, -1, handle->ca,
 741                         on_response_default_set, evt_cb_data);
 742
 743         return TAPI_API_SUCCESS;
 744 }
 745
 746 EXPORT_API int tel_get_network_preferred_plmn(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 747 {
 748         struct tapi_resp_data *evt_cb_data = NULL;
 749
 750         dbg("Func Entrance");
 751
 752         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 753
 754         g_dbus_connection_call(handle->dbus_connection,
 755                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 756                         "GetPreferredPlmn", NULL, NULL,
 757                         G_DBUS_CALL_FLAGS_NONE, -1, handle->ca,
 758                         (GAsyncReadyCallback) on_response_get_network_preferred_plmn, evt_cb_data);
 759
 760         return TAPI_API_SUCCESS;
 761 }
 762
 763 EXPORT_API int tel_set_network_band(TapiHandle *handle, TelNetworkBandPreferred_t mode, TelNetworkBand_t band, tapi_response_cb callback, void *user_data)
 764 {
 765         struct tapi_resp_data *evt_cb_data = NULL;
 766         GVariant *param;
 767
 768         dbg("Func Entrance");
 769
 770         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 771
 772         param = g_variant_new("(ii)",
 773                         band,
 774                         mode);
 775
 776         g_dbus_connection_call(handle->dbus_connection,
 777                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 778                         "SetBand", param, NULL,
 779                         G_DBUS_CALL_FLAGS_NONE, -1, handle->ca,
 780                         on_response_default_set, evt_cb_data);
 781
 782         return TAPI_API_SUCCESS;
 783 }
 784
 785 EXPORT_API int tel_get_network_band(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 786 {
 787         struct tapi_resp_data *evt_cb_data = NULL;
 788
 789         dbg("Func Entrance");
 790
 791         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 792
 793         g_dbus_connection_call(handle->dbus_connection,
 794                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 795                         "GetBand", NULL, NULL,
 796                         G_DBUS_CALL_FLAGS_NONE, -1, handle->ca,
 797                         on_response_get_network_band, evt_cb_data);
 798
 799         return TAPI_API_SUCCESS;
 800 }
 801
 802 EXPORT_API int tel_set_network_mode(TapiHandle *handle, int mode, tapi_response_cb callback, void *user_data)
 803 {
 804         struct tapi_resp_data *evt_cb_data = NULL;
 805         GVariant *param;
 806
 807         dbg("Func Entrance");
 808
 809         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 810
 811         param = g_variant_new("(i)",
 812                         mode);
 813
 814         g_dbus_connection_call(handle->dbus_connection,
 815                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 816                         "SetMode", param, NULL,
 817                         G_DBUS_CALL_FLAGS_NONE, -1, handle->ca,
 818                         on_response_default_set, evt_cb_data);
 819
 820         return TAPI_API_SUCCESS;
 821 }
 822
 823 EXPORT_API int tel_get_network_mode(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 824 {
 825         struct tapi_resp_data *evt_cb_data = NULL;
 826
 827         dbg("Func Entrance");
 828
 829         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 830
 831         g_dbus_connection_call(handle->dbus_connection,
 832                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 833                         "GetMode", NULL, NULL,
 834                         G_DBUS_CALL_FLAGS_NONE, -1, handle->ca,
 835                         on_response_get_network_mode, evt_cb_data);
 836
 837         return TAPI_API_SUCCESS;
 838 }
 839
 840 EXPORT_API int tel_set_network_service_domain(TapiHandle *handle, TelNetworkServiceDomain_t domain, tapi_response_cb callback, void *user_data)
 841 {
 842         struct tapi_resp_data *evt_cb_data = NULL;
 843         GVariant *param;
 844
 845         dbg("Func Entrance");
 846
 847         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 848
 849         param = g_variant_new("(i)", domain);
 850
 851         g_dbus_connection_call(handle->dbus_connection,
 852                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 853                         "SetServiceDomain", param, NULL,
 854                         G_DBUS_CALL_FLAGS_NONE, -1, handle->ca,
 855                         on_response_default_set, evt_cb_data);
 856
 857         return TAPI_API_SUCCESS;
 858 }
 859
 860 EXPORT_API int tel_get_network_service_domain(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 861 {
 862         struct tapi_resp_data *evt_cb_data = NULL;
 863
 864         dbg("Func Entrance");
 865
 866         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 867
 868         g_dbus_connection_call(handle->dbus_connection,
 869                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 870                         "GetServiceDomain", NULL, NULL,
 871                         G_DBUS_CALL_FLAGS_NONE, -1, handle->ca,
 872                         on_response_get_network_service_domain, evt_cb_data);
 873
 874         return TAPI_API_SUCCESS;
 875 }
 876
 877 EXPORT_API int tel_cancel_network_manual_search(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 878 {
 879         struct tapi_resp_data *evt_cb_data = NULL;
 880
 881         dbg("Func Entrance");
 882
 883         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 884
 885         g_dbus_connection_call(handle->dbus_connection,
 886                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 887                         "SearchCancel", NULL, NULL,
 888                         G_DBUS_CALL_FLAGS_NONE, -1, handle->ca,
 889                         on_response_default_set, evt_cb_data);
 890
 891         return TAPI_API_SUCCESS;
 892 }
 893
 894 EXPORT_API int tel_get_network_serving(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 895 {
 896         struct tapi_resp_data *evt_cb_data = NULL;
 897
 898         dbg("Func Entrance");
 899
 900         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 901
 902         g_dbus_connection_call(handle->dbus_connection,
 903                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 904                         "GetServingNetwork", NULL, NULL,
 905                         G_DBUS_CALL_FLAGS_NONE, -1, handle->ca,
 906                         on_response_get_network_serving, evt_cb_data);
 907
 908         return TAPI_API_SUCCESS;
 909 }
 910
 911 EXPORT_API int tel_get_network_neighboring_cell_info(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 912 {
 913         struct tapi_resp_data *evt_cb_data = NULL;
 914
 915         dbg("Func Entrance");
 916
 917         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 918
 919         g_dbus_connection_call(handle->dbus_connection,
 920                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 921                         "GetNgbrCellInfo", NULL, NULL,
 922                         G_DBUS_CALL_FLAGS_NONE, -1, handle->ca,
 923                         on_response_get_neighboring_cell_info, evt_cb_data);
 924
 925         return TAPI_API_SUCCESS;
 926 }
 927