src/tapi_network.c

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