src/dtapi_network.c

   1 /*
   2  * tel-plugin-dbus-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 <string.h>
  23 #include <stdlib.h>
  24
  25 #include <glib.h>
  26
  27 #include <tcore.h>
  28 #include <server.h>
  29 #include <plugin.h>
  30 #include <co_network.h>
  31
  32 #include "generated-code.h"
  33 #include "dtapi_common.h"
  34
  35 /*
  36  * Application used properties
  37  */
  38 #define NET_PROP_NONE           0x0000
  39 #define NET_PROP_SVC_TYPE       0x0001
  40 #define NET_PROP_ROAM           0x0002
  41 #define NET_PROP_PLMN           0x0004
  42 #define NET_PROP_NAME_OPTION 0x0100
  43 #define NET_PROP_SPN            0x0200
  44 #define NET_PROP_NWNAME 0x0400
  45 #define NET_PROP_EMIT           0x0FFF
  46
  47 /*
  48  * Extra properties
  49  */
  50 #define NET_PROP_CS             0x1000
  51 #define NET_PROP_PS             0x2000
  52 #define NET_PROP_ACT            0x4000
  53 #define NET_PROP_ALL            0xFFFF
  54
  55 typedef struct {
  56         int type;
  57         int svc_type;
  58         int ps_type;
  59         gboolean roaming;
  60         int act;
  61         int cs;
  62         int ps;
  63         int name_option;
  64         char *plmn;
  65         char *spn;
  66         char *nwname;
  67 } NetworkPropertyInfo;
  68
  69 static int __convert_act_to_systemtype(enum telephony_network_access_technology act)
  70 {
  71         switch (act) {
  72         case NETWORK_ACT_UNKNOWN:
  73                 return 0;
  74
  75         case NETWORK_ACT_GSM:
  76                 return 1;
  77
  78         case NETWORK_ACT_GPRS:
  79                 return 2;
  80
  81         case NETWORK_ACT_EGPRS:
  82                 return 3;
  83
  84         case NETWORK_ACT_UMTS:
  85                 return 5;
  86
  87         case NETWORK_ACT_GSM_UTRAN:
  88                 return 6;
  89
  90         case NETWORK_ACT_IS95A:
  91                 return 8;
  92
  93         case NETWORK_ACT_IS95B:
  94                 return 9;
  95
  96         case NETWORK_ACT_CDMA_1X:
  97                 return 10;
  98
  99         case NETWORK_ACT_EVDO_REV0:
 100                 return 11;
 101
 102         case NETWORK_ACT_CDMA_1X_EVDO_REV0:
 103                 return 12;
 104
 105         case NETWORK_ACT_EVDO_REVA:
 106                 return 13;
 107
 108         case NETWORK_ACT_CDMA_1X_EVDO_REVA:
 109                 return 14;
 110
 111         case NETWORK_ACT_EVDO_REVB:
 112                 return 15;
 113
 114         case NETWORK_ACT_CDMA_1X_EVDO_REVB:
 115                 return 16;
 116
 117         case NETWORK_ACT_EVDV:
 118                 return 17;
 119
 120         case NETWORK_ACT_EHRPD:
 121                 return 18;
 122
 123         case NETWORK_ACT_LTE:
 124                 return 19;
 125
 126         default:
 127         break;
 128         }
 129
 130         return 0;
 131 }
 132
 133 static int __convert_name_priority_to_option(enum tcore_network_name_priority priority)
 134 {
 135         switch (priority) {
 136         case TCORE_NETWORK_NAME_PRIORITY_SPN:
 137                 return 1; /* NETWORK_NAME_OPTION_SPN */
 138
 139         case TCORE_NETWORK_NAME_PRIORITY_NETWORK:
 140                 return 2; /* NETWORK_NAME_OPTION_OPERATOR */
 141
 142         case TCORE_NETWORK_NAME_PRIORITY_ANY:
 143                 return 3; /* NETWORK_NAME_OPTION_ANY */
 144
 145         default:
 146         break;
 147         }
 148
 149         return 0; /* NETWORK_NAME_OPTION_NONE */
 150 }
 151
 152 static void __get_current_network_status(CoreObject *o,
 153         NetworkPropertyInfo *current, int req_type)
 154 {
 155         if (!o || !current)
 156                 return;
 157
 158         if (req_type & NET_PROP_SVC_TYPE) {
 159                 enum telephony_network_service_type svc_type;
 160
 161                 tcore_network_get_service_type(o, &svc_type);
 162                 current->svc_type = svc_type;
 163         }
 164
 165         if (req_type & NET_PROP_ROAM)
 166                 current->roaming = tcore_network_get_roaming_state(o);
 167
 168         if (req_type & NET_PROP_PLMN)
 169                 current->plmn = tcore_network_get_plmn(o);
 170
 171         if (req_type & NET_PROP_NAME_OPTION) {
 172                 enum tcore_network_name_priority priority = TCORE_NETWORK_NAME_PRIORITY_UNKNOWN;
 173
 174                 tcore_network_get_network_name_priority(o, &priority);
 175                 current->name_option = __convert_name_priority_to_option(priority);
 176         }
 177
 178         if (req_type & NET_PROP_SPN)
 179                 current->spn = tcore_network_get_network_name(o, TCORE_NETWORK_NAME_TYPE_SPN);
 180
 181         if (req_type & NET_PROP_NWNAME) {
 182                 char *nwname = tcore_network_get_network_name(o, TCORE_NETWORK_NAME_TYPE_FULL);
 183
 184                 if (!nwname || strlen(nwname) == 0)
 185                         nwname = tcore_network_get_network_name(o, TCORE_NETWORK_NAME_TYPE_SHORT);
 186                 current->nwname = nwname;
 187         }
 188
 189         if (req_type & NET_PROP_CS) {
 190                 enum telephony_network_service_domain_status cs;
 191                 tcore_network_get_service_status(o, TCORE_NETWORK_SERVICE_DOMAIN_TYPE_CIRCUIT, &cs);
 192
 193                 current->cs = cs;
 194         }
 195
 196         if (req_type & NET_PROP_PS) {
 197                 enum telephony_network_service_domain_status ps;
 198
 199                 tcore_network_get_service_status(o, TCORE_NETWORK_SERVICE_DOMAIN_TYPE_PACKET, &ps);
 200                 current->ps = ps;
 201         }
 202
 203         if (req_type & NET_PROP_ACT) {
 204                 enum telephony_network_access_technology act = NETWORK_ACT_UNKNOWN;
 205
 206                 tcore_network_get_access_technology(o, &act);
 207                 current->act = __convert_act_to_systemtype(act);
 208         }
 209 }
 210
 211 static int __check_property_change(TelephonyNetwork *network, CoreObject *o,
 212         NetworkPropertyInfo *current, int req_type)
 213 {
 214         int changed_type = NET_PROP_NONE;
 215
 216         if (!current || !o)
 217                 return NET_PROP_NONE;
 218
 219         __get_current_network_status(o, current, req_type);
 220
 221         if (req_type & NET_PROP_SVC_TYPE)
 222                 if (telephony_network_get_service_type(network) != current->svc_type)
 223                         changed_type |= NET_PROP_SVC_TYPE;
 224
 225         if (req_type & NET_PROP_ROAM)
 226                 if (telephony_network_get_roaming_status(network) != current->roaming)
 227                         changed_type |= NET_PROP_ROAM;
 228
 229         if (req_type & NET_PROP_PLMN) {
 230                 if (current->plmn) {
 231                         const gchar *prev_plmn = telephony_network_get_plmn(network);
 232
 233                         if (!prev_plmn || strcmp(prev_plmn, current->plmn) != 0)
 234                                 changed_type |= NET_PROP_PLMN;
 235                 }
 236         }
 237
 238         if (req_type & NET_PROP_NAME_OPTION)
 239                 if (telephony_network_get_name_option(network) != current->name_option)
 240                         changed_type |= NET_PROP_NAME_OPTION;
 241
 242         if (req_type & NET_PROP_SPN) {
 243                 if (current->spn) {
 244                         const gchar *prev_spn = telephony_network_get_spn_name(network);
 245
 246                         if (!prev_spn || strcmp(prev_spn, current->spn) != 0)
 247                                 changed_type |= NET_PROP_SPN;
 248                 }
 249         }
 250
 251         if (req_type & NET_PROP_NWNAME) {
 252                 if (current->nwname) {
 253                         const gchar *prev_nwname = telephony_network_get_network_name(network);
 254
 255                         if (!prev_nwname || strcmp(prev_nwname, current->nwname) != 0)
 256                                 changed_type |= NET_PROP_NWNAME;
 257                 }
 258         }
 259
 260         if (req_type & NET_PROP_CS)
 261                 if (telephony_network_get_circuit_status(network) != current->cs)
 262                         changed_type |= NET_PROP_CS;
 263
 264         if (req_type & NET_PROP_PS)
 265                 if (telephony_network_get_packet_status(network) != current->ps)
 266                         changed_type |= NET_PROP_PS;
 267
 268         if (req_type & NET_PROP_ACT)
 269                 if (telephony_network_get_access_technology(network) != current->act)
 270                         changed_type |= NET_PROP_ACT;
 271
 272         return changed_type;
 273 }
 274
 275 static void __update_network_properties(TelephonyNetwork *network,
 276         const char *cp_name, NetworkPropertyInfo *current, int update_type)
 277 {
 278         if (!current)
 279                 return;
 280
 281         if (update_type & NET_PROP_SVC_TYPE) {
 282                 telephony_network_set_service_type(network, current->svc_type);
 283
 284                 if (current->svc_type != NETWORK_SERVICE_TYPE_3G)
 285                         telephony_network_set_ps_type(network, TELEPHONY_HSDPA_OFF);
 286         }
 287
 288         if (update_type & NET_PROP_ROAM)
 289                 telephony_network_set_roaming_status(network, current->roaming);
 290
 291         if (update_type & NET_PROP_PLMN)
 292                 telephony_network_set_plmn(network, current->plmn);
 293
 294         if (update_type & NET_PROP_NAME_OPTION)
 295                 telephony_network_set_name_option(network, current->name_option);
 296
 297         if (update_type & NET_PROP_SPN)
 298                 telephony_network_set_spn_name(network, current->spn);
 299
 300         if (update_type & NET_PROP_NWNAME)
 301                 telephony_network_set_network_name(network, current->nwname);
 302
 303         if (update_type & NET_PROP_CS)
 304                 telephony_network_set_circuit_status(network, current->cs);
 305
 306         if (update_type & NET_PROP_PS)
 307                 telephony_network_set_packet_status(network, current->ps);
 308
 309         if (update_type & NET_PROP_ACT)
 310                 telephony_network_set_access_technology(network, current->act);
 311 }
 312
 313 static int __add_default_property_type(TelephonyNetwork *network, CoreObject *o, int req_type)
 314 {
 315         /*
 316          * If SVC_TYPE was changed,
 317          * other properties (ACT, OPTION, SPN, NWNAME) may also be changed together
 318          */
 319         if (req_type & NET_PROP_SVC_TYPE) {
 320                 NetworkPropertyInfo current = {0, -1, -1, 0, -1, -1, -1, -1, NULL, NULL, NULL};
 321
 322                 if (__check_property_change(network, o, &current, NET_PROP_SVC_TYPE)) {
 323                         /*
 324                          * If SVC_TYPE was really changed,
 325                          * we should add others to default checking value
 326                          */
 327                         req_type |= (NET_PROP_ACT | NET_PROP_NAME_OPTION | NET_PROP_SPN | NET_PROP_NWNAME);
 328                 }
 329         }
 330
 331         /*
 332          * If PLMN was changed,
 333          * other properties (ROAM,OPTION,SPN,NWNAME) may also be changed together
 334          */
 335         if (req_type & NET_PROP_PLMN) {
 336                 NetworkPropertyInfo current = {0, -1, -1, 0, -1, -1, -1, -1, NULL, NULL, NULL};
 337
 338                 if (__check_property_change(network, o, &current, NET_PROP_PLMN)) {
 339                         /*
 340                          * If PLMN was really changed,
 341                          * we should add anothers to default checking value
 342                          */
 343                         req_type |= (NET_PROP_ROAM | NET_PROP_NAME_OPTION | NET_PROP_SPN | NET_PROP_NWNAME);
 344                 }
 345                 g_free(current.plmn);
 346         }
 347
 348         return req_type;
 349 }
 350
 351 static void __check_network_properties(TelephonyNetwork *network, CoreObject *o,
 352         const char *cp_name, int req_type)
 353 {
 354         int changed_type = NET_PROP_NONE;
 355         int emit_type = NET_PROP_NONE;
 356         NetworkPropertyInfo current = {0, -1, -1, 0, -1, -1, -1, -1, NULL, NULL, NULL};
 357
 358         req_type = __add_default_property_type(network, o, req_type);
 359         changed_type = __check_property_change(network, o, &current, req_type);
 360
 361         if (changed_type)
 362                 __update_network_properties(network, cp_name, &current, changed_type);
 363
 364         emit_type = (changed_type & NET_PROP_EMIT);
 365         if (emit_type) {
 366                 info("[%s] PROPTYPE: [%04x] svc: [%d] roam: [%s] plmn: [%s] prio: [%d] spn: [%s] nwname: [%s]",
 367                         cp_name, emit_type, current.svc_type,
 368                         (current.roaming ? "YES" : "NO"), current.plmn,
 369                         current.name_option, current.spn, current.nwname);
 370
 371                 telephony_network_emit_property_info(network, emit_type,
 372                         current.svc_type, current.roaming, current.name_option,
 373                         current.plmn, current.spn, current.nwname);
 374         }
 375
 376         g_free(current.plmn);
 377         g_free(current.spn);
 378         g_free(current.nwname);
 379 }
 380
 381 static enum tcore_hook_return on_hook_ps_protocol_status(Server *s,
 382         CoreObject *source, enum tcore_notification_command command,
 383         unsigned int data_len, void *data, void *user_data)
 384 {
 385         const struct tnoti_ps_protocol_status *protocol_status = data;
 386
 387         TelephonyObjectSkeleton *object;
 388         TelephonyNetwork *network = NULL;
 389         struct custom_data *ctx = user_data;
 390         const char *cp_name;
 391         char *path;
 392
 393         enum telephony_ps_protocol_status ps_protocol_status = TELEPHONY_HSDPA_OFF;
 394
 395         cp_name = tcore_server_get_cp_name_by_plugin(tcore_object_ref_plugin(source));
 396         if (cp_name == NULL) {
 397                 err("CP name is NULL");
 398                 return TCORE_HOOK_RETURN_CONTINUE;
 399         }
 400
 401         info("[%s] PS_PROTOCOL_STATUS - Status: [%d]", cp_name, protocol_status->status);
 402
 403         path = g_strdup_printf("%s/%s", MY_DBUS_PATH, cp_name);
 404
 405         /* Look-up Hash table for Object */
 406         object = g_hash_table_lookup(ctx->objects, path);
 407         g_free(path);
 408         if (object == NULL) {
 409                 err("Object is NOT defined!!!");
 410                 return TCORE_HOOK_RETURN_CONTINUE;
 411         }
 412
 413         network = telephony_object_peek_network(TELEPHONY_OBJECT(object));
 414         if (network == NULL) {
 415                 err("Network object is NULL!!!");
 416                 return TCORE_HOOK_RETURN_CONTINUE;
 417         }
 418
 419         /*
 420          * Do not check service_type.
 421          * In case of +CGREG is invoked before +CREG(Z1 device),
 422          * ps_type is not set because service_type is unknown yet.
 423          *
 424         if (telephony_network_get_service_type (network) < NETWORK_SERVICE_TYPE_2G) {
 425                 telephony_network_set_ps_type(network, TELEPHONY_HSDPA_OFF);
 426                 return TCORE_HOOK_RETURN_CONTINUE;
 427         }
 428         */
 429
 430         switch (protocol_status->status) {
 431         case TELEPHONY_HSDPA_OFF:
 432                 ps_protocol_status = TELEPHONY_HSDPA_OFF;
 433         break;
 434
 435         case TELEPHONY_HSDPA_ON:
 436                 ps_protocol_status = TELEPHONY_HSDPA_ON;
 437         break;
 438
 439         case TELEPHONY_HSUPA_ON:
 440                 ps_protocol_status = TELEPHONY_HSUPA_ON;
 441         break;
 442
 443         case TELEPHONY_HSPA_ON:
 444                 ps_protocol_status = TELEPHONY_HSPA_ON;
 445         break;
 446
 447         case TELEPHONY_HSPAP_ON:
 448                 ps_protocol_status = TELEPHONY_HSPAP_ON;
 449         break;
 450
 451         default:
 452                 err("Unhandled protocol status!");
 453         break;
 454         }
 455
 456         telephony_network_set_ps_type(network, ps_protocol_status);
 457
 458         return TCORE_HOOK_RETURN_CONTINUE;
 459 }
 460
 461 static gboolean on_network_search(TelephonyNetwork *network,
 462         GDBusMethodInvocation *invocation, gpointer user_data)
 463 {
 464         struct custom_data *ctx = user_data;
 465
 466         /* Dispatch request */
 467         dtapi_dispatch_request(ctx, network, invocation,
 468                 TREQ_NETWORK_SEARCH,
 469                 NULL, 0);
 470
 471         return TRUE;
 472 }
 473
 474 static gboolean on_network_search_cancel(TelephonyNetwork *network,
 475         GDBusMethodInvocation *invocation, gpointer user_data)
 476 {
 477         struct custom_data *ctx = user_data;
 478
 479         /* Dispatch request */
 480         dtapi_dispatch_request(ctx, network, invocation,
 481                 TREQ_NETWORK_SET_CANCEL_MANUAL_SEARCH,
 482                 NULL, 0);
 483
 484         return TRUE;
 485 }
 486
 487 static gboolean on_network_get_selection_mode(TelephonyNetwork *network,
 488         GDBusMethodInvocation *invocation, gpointer user_data)
 489 {
 490         struct custom_data *ctx = user_data;
 491
 492         /* Dispatch request */
 493         dtapi_dispatch_request(ctx, network, invocation,
 494                 TREQ_NETWORK_GET_PLMN_SELECTION_MODE,
 495                 NULL, 0);
 496
 497         return TRUE;
 498 }
 499
 500 static gboolean on_network_set_selection_mode(TelephonyNetwork *network,
 501         GDBusMethodInvocation *invocation,
 502         gint mode, const gchar *plmn, gint act, gpointer user_data)
 503 {
 504         struct treq_network_set_plmn_selection_mode req;
 505         struct custom_data *ctx = user_data;
 506
 507         memset(&req, 0x0, sizeof(struct treq_network_set_plmn_selection_mode));
 508
 509         if (mode == 0) {        /* Automatic */
 510                 req.mode = NETWORK_SELECT_MODE_AUTOMATIC;
 511         } else if (mode == 1) { /* Manual */
 512                 req.mode = NETWORK_SELECT_MODE_MANUAL;
 513                 snprintf(req.plmn, 7, "%s", plmn);
 514                 req.act = act;
 515         } else {
 516                 FAIL_RESPONSE(invocation, DEFAULT_MSG_REQ_FAILED);
 517                 return TRUE;
 518         }
 519         dbg("Mode: [%d] PLMN: [%s] AcT: [%d]", req.mode, req.plmn, req.act);
 520
 521         /* Dispatch request */
 522         dtapi_dispatch_request(ctx, network, invocation,
 523                 TREQ_NETWORK_SET_PLMN_SELECTION_MODE,
 524                 &req, sizeof(struct treq_network_set_plmn_selection_mode));
 525
 526         return TRUE;
 527 }
 528
 529
 530 static gboolean on_network_set_service_domain(TelephonyNetwork *network,
 531         GDBusMethodInvocation *invocation, gint domain, gpointer user_data)
 532 {
 533         struct treq_network_set_service_domain req;
 534         struct custom_data *ctx = user_data;
 535
 536         req.domain = domain;
 537
 538         /* Dispatch request */
 539         dtapi_dispatch_request(ctx, network, invocation,
 540                 TREQ_NETWORK_SET_SERVICE_DOMAIN,
 541                 &req, sizeof(struct treq_network_set_service_domain));
 542
 543         return TRUE;
 544 }
 545
 546 static gboolean on_network_get_service_domain(TelephonyNetwork *network,
 547         GDBusMethodInvocation *invocation, gpointer user_data)
 548 {
 549         struct custom_data *ctx = user_data;
 550
 551         /* Dispatch request */
 552         dtapi_dispatch_request(ctx, network, invocation,
 553                 TREQ_NETWORK_GET_SERVICE_DOMAIN,
 554                 NULL, 0);
 555
 556         return TRUE;
 557 }
 558
 559 static gboolean on_network_set_band(TelephonyNetwork *network,
 560         GDBusMethodInvocation *invocation,
 561         gint band, gint mode, gpointer user_data)
 562 {
 563         struct treq_network_set_band req;
 564         struct custom_data *ctx = user_data;
 565
 566         req.mode = mode;
 567         req.band = band;
 568
 569         /* Dispatch request */
 570         dtapi_dispatch_request(ctx, network, invocation,
 571                 TREQ_NETWORK_SET_BAND,
 572                 &req, sizeof(struct treq_network_set_band));
 573
 574         return TRUE;
 575 }
 576
 577 static gboolean on_network_get_band(TelephonyNetwork *network,
 578         GDBusMethodInvocation *invocation, gpointer user_data)
 579 {
 580         struct custom_data *ctx = user_data;
 581
 582         /* Dispatch request */
 583         dtapi_dispatch_request(ctx, network, invocation,
 584                 TREQ_NETWORK_GET_BAND,
 585                 NULL, 0);
 586
 587         return TRUE;
 588 }
 589
 590 static gboolean on_network_set_mode(TelephonyNetwork *network,
 591         GDBusMethodInvocation *invocation, gint mode, gpointer user_data)
 592 {
 593         struct treq_network_set_mode req;
 594         struct custom_data *ctx = user_data;
 595
 596         req.mode = mode;
 597
 598         /* Dispatch request */
 599         dtapi_dispatch_request(ctx, network, invocation,
 600                 TREQ_NETWORK_SET_MODE,
 601                 &req, sizeof(struct treq_network_set_mode));
 602
 603         return TRUE;
 604 }
 605
 606 static gboolean on_network_get_mode(TelephonyNetwork *network,
 607         GDBusMethodInvocation *invocation, gpointer user_data)
 608 {
 609         struct custom_data *ctx = user_data;
 610
 611         /* Dispatch request */
 612         dtapi_dispatch_request(ctx, network, invocation,
 613                 TREQ_NETWORK_GET_MODE,
 614                 NULL, 0);
 615
 616         return TRUE;
 617 }
 618
 619 static gboolean on_network_set_preferred_plmn(TelephonyNetwork *network,
 620         GDBusMethodInvocation *invocation,
 621         gint mode, gint ef_index, gint act, const gchar *plmn, gpointer user_data)
 622 {
 623         struct treq_network_set_preferred_plmn req;
 624         struct custom_data *ctx = user_data;
 625
 626         req.operation = mode;
 627         req.ef_index = ef_index;
 628         req.act = act;
 629
 630         memcpy(req.plmn, plmn, 6);
 631
 632         if (strlen(plmn) <= 5)
 633                 req.plmn[5] = '#';
 634
 635         /* Dispatch request */
 636         dtapi_dispatch_request(ctx, network, invocation,
 637                 TREQ_NETWORK_SET_PREFERRED_PLMN,
 638                 &req, sizeof(struct treq_network_set_preferred_plmn));
 639
 640         return TRUE;
 641 }
 642
 643 static gboolean on_network_get_preferred_plmn(TelephonyNetwork *network,
 644         GDBusMethodInvocation *invocation, gpointer user_data)
 645 {
 646         struct custom_data *ctx = user_data;
 647
 648         /* Dispatch request */
 649         dtapi_dispatch_request(ctx, network, invocation,
 650                 TREQ_NETWORK_GET_PREFERRED_PLMN,
 651                 NULL, 0);
 652
 653         return TRUE;
 654 }
 655
 656 static gboolean on_network_get_serving_network(TelephonyNetwork *network,
 657         GDBusMethodInvocation *invocation, gpointer user_data)
 658 {
 659         struct custom_data *ctx = user_data;
 660
 661         /* Dispatch request */
 662         dtapi_dispatch_request(ctx, network, invocation,
 663                 TREQ_NETWORK_GET_SERVING_NETWORK,
 664                 NULL, 0);
 665
 666         return TRUE;
 667 }
 668
 669 static gboolean on_network_get_neighboring_cell_info(TelephonyNetwork *network,
 670         GDBusMethodInvocation *invocation, gpointer user_data)
 671 {
 672         struct custom_data *ctx = user_data;
 673
 674         /* Dispatch request */
 675         dtapi_dispatch_request(ctx, network, invocation,
 676                 TREQ_NETWORK_GET_NEIGHBORING_CELL_INFO,
 677                 NULL, 0);
 678
 679         return TRUE;
 680 }
 681
 682 static gboolean on_network_set_default_data_subscription(TelephonyNetwork *network,
 683         GDBusMethodInvocation *invocation, gpointer user_data)
 684 {
 685         struct custom_data *ctx = user_data;
 686
 687         /* Dispatch request */
 688         dtapi_dispatch_request(ctx, network, invocation,
 689                 TREQ_NETWORK_SET_DEFAULT_DATA_SUBSCRIPTION,
 690                 NULL, 0);
 691
 692         return TRUE;
 693 }
 694
 695 static gboolean on_network_get_default_data_subscription(TelephonyNetwork *network,
 696         GDBusMethodInvocation *invocation, gpointer user_data)
 697 {
 698         struct custom_data *ctx = user_data;
 699
 700         /* Dispatch request */
 701         dtapi_dispatch_request(ctx, network, invocation,
 702                 TREQ_NETWORK_GET_DEFAULT_DATA_SUBSCRIPTION,
 703                 NULL, 0);
 704
 705         return TRUE;
 706 }
 707
 708 static gboolean on_network_set_default_subs(TelephonyNetwork *network,
 709         GDBusMethodInvocation *invocation, gpointer user_data)
 710 {
 711         struct custom_data *ctx = user_data;
 712
 713         /* Dispatch request */
 714         dtapi_dispatch_request(ctx, network, invocation,
 715                 TREQ_NETWORK_SET_DEFAULT_SUBSCRIPTION,
 716                 NULL, 0);
 717
 718         return TRUE;
 719 }
 720
 721 static gboolean on_network_get_default_subs(TelephonyNetwork *network,
 722         GDBusMethodInvocation *invocation, gpointer user_data)
 723 {
 724         struct custom_data *ctx = user_data;
 725
 726         /* Dispatch request */
 727         dtapi_dispatch_request(ctx, network, invocation,
 728                 TREQ_NETWORK_GET_DEFAULT_SUBSCRIPTION,
 729                 NULL, 0);
 730
 731         return TRUE;
 732 }
 733
 734 static gboolean on_network_set_emergency_callback_mode(TelephonyNetwork *network,
 735         GDBusMethodInvocation *invocation, gint mode, gpointer user_data)
 736 {
 737         struct treq_network_set_emergency_callback_mode req;
 738         struct custom_data *ctx = user_data;
 739
 740         req.mode = mode;
 741
 742         /* Dispatch request */
 743         dtapi_dispatch_request(ctx, network, invocation,
 744                 TREQ_NETWORK_SET_EMERGENCY_CALLBACK_MODE,
 745                 &req, sizeof(struct treq_network_set_emergency_callback_mode));
 746
 747         return TRUE;
 748 }
 749
 750 static gboolean on_network_set_roaming_preference(TelephonyNetwork *network,
 751         GDBusMethodInvocation *invocation,  gint roam_pref, gpointer user_data)
 752 {
 753         struct treq_network_set_roaming_preference req;
 754         struct custom_data *ctx = user_data;
 755
 756         req.roam_pref = roam_pref;
 757
 758         /* Dispatch request */
 759         dtapi_dispatch_request(ctx, network, invocation,
 760                 TREQ_NETWORK_SET_ROAMING_PREFERENCE,
 761                 &req, sizeof(struct treq_network_set_roaming_preference));
 762
 763         return TRUE;
 764 }
 765
 766 static gboolean on_network_get_roaming_preference(TelephonyNetwork *network,
 767         GDBusMethodInvocation *invocation, gpointer user_data)
 768 {
 769         struct custom_data *ctx = user_data;
 770
 771         /* Dispatch request */
 772         dtapi_dispatch_request(ctx, network, invocation,
 773                 TREQ_NETWORK_GET_ROAMING_PREFERENCE,
 774                 NULL, 0);
 775
 776         return TRUE;
 777 }
 778
 779 gboolean dbus_plugin_setup_network_interface(TelephonyObjectSkeleton *object,
 780         struct custom_data *ctx)
 781 {
 782         TelephonyNetwork *network;
 783
 784         network = telephony_network_skeleton_new();
 785         telephony_object_skeleton_set_network(object, network);
 786         g_object_unref(network);
 787
 788         dbg("network = %p", network);
 789
 790         /*
 791          * Register signal handlers for Network interface
 792          */
 793         g_signal_connect(network,
 794                 "handle-search",
 795                 G_CALLBACK(on_network_search), ctx);
 796
 797         g_signal_connect(network,
 798                 "handle-search-cancel",
 799                 G_CALLBACK(on_network_search_cancel), ctx);
 800
 801         g_signal_connect(network,
 802                 "handle-set-selection-mode",
 803                 G_CALLBACK(on_network_set_selection_mode), ctx);
 804
 805         g_signal_connect(network,
 806                 "handle-get-selection-mode",
 807                 G_CALLBACK(on_network_get_selection_mode), ctx);
 808
 809         g_signal_connect(network,
 810                 "handle-set-service-domain",
 811                 G_CALLBACK(on_network_set_service_domain), ctx);
 812
 813         g_signal_connect(network,
 814                 "handle-get-service-domain",
 815                 G_CALLBACK(on_network_get_service_domain), ctx);
 816
 817         g_signal_connect(network,
 818                 "handle-set-band",
 819                 G_CALLBACK(on_network_set_band), ctx);
 820
 821         g_signal_connect(network,
 822                 "handle-get-band",
 823                 G_CALLBACK(on_network_get_band), ctx);
 824
 825         g_signal_connect(network,
 826                 "handle-set-mode",
 827                 G_CALLBACK(on_network_set_mode), ctx);
 828
 829         g_signal_connect(network,
 830                 "handle-get-mode",
 831                 G_CALLBACK(on_network_get_mode), ctx);
 832
 833         g_signal_connect(network,
 834                 "handle-set-preferred-plmn",
 835                 G_CALLBACK(on_network_set_preferred_plmn), ctx);
 836
 837         g_signal_connect(network,
 838                 "handle-get-preferred-plmn",
 839                 G_CALLBACK(on_network_get_preferred_plmn), ctx);
 840
 841         g_signal_connect(network,
 842                 "handle-get-serving-network",
 843                 G_CALLBACK(on_network_get_serving_network), ctx);
 844
 845         g_signal_connect(network,
 846                 "handle-get-ngbr-cell-info",
 847                 G_CALLBACK(on_network_get_neighboring_cell_info), ctx);
 848
 849         g_signal_connect(network,
 850                 "handle-set-default-data-subscription",
 851                 G_CALLBACK(on_network_set_default_data_subscription), ctx);
 852
 853         g_signal_connect(network,
 854                 "handle-get-default-data-subscription",
 855                 G_CALLBACK(on_network_get_default_data_subscription), ctx);
 856
 857         g_signal_connect(network,
 858                 "handle-set-default-subscription",
 859                 G_CALLBACK(on_network_set_default_subs), ctx);
 860
 861         g_signal_connect(network,
 862                 "handle-get-default-subscription",
 863                 G_CALLBACK(on_network_get_default_subs), ctx);
 864
 865         g_signal_connect(network,
 866                 "handle-set-emergency-callback-mode",
 867                 G_CALLBACK(on_network_set_emergency_callback_mode), ctx);
 868
 869         g_signal_connect(network,
 870                 "handle-set-roaming-preference",
 871                 G_CALLBACK(on_network_set_roaming_preference), ctx);
 872
 873         g_signal_connect(network,
 874                 "handle-get-roaming-preference",
 875                 G_CALLBACK(on_network_get_roaming_preference), ctx);
 876
 877         /*
 878          * Initialize DBUS properties
 879          */
 880         telephony_network_set_access_technology(network, NETWORK_ACT_UNKNOWN);
 881         telephony_network_set_cell_id(network, 0);
 882         telephony_network_set_ims_voice_status(network, NETWORK_IMS_VOICE_UNKNOWN);
 883         telephony_network_set_volte_enable(network, FALSE);
 884         telephony_network_set_circuit_status(network, NETWORK_SERVICE_DOMAIN_STATUS_NO);
 885         telephony_network_set_lac(network, 0);
 886         telephony_network_set_tac(network, 0);
 887         telephony_network_set_name_option(network, NETWORK_NAME_OPTION_NONE);
 888         telephony_network_set_packet_status(network, NETWORK_SERVICE_DOMAIN_STATUS_NO);
 889         telephony_network_set_sig_dbm(network, 0);
 890         telephony_network_set_roaming_status(network, FALSE);
 891         telephony_network_set_ps_type(network, TELEPHONY_HSDPA_OFF);
 892         telephony_network_set_service_type(network, NETWORK_SERVICE_TYPE_UNKNOWN);
 893         telephony_network_set_sig_level(network, 0);
 894         telephony_network_set_plmn(network, NULL);
 895         telephony_network_set_spn_name(network, NULL);
 896         telephony_network_set_network_name(network, NULL);
 897
 898         tcore_server_remove_notification_hook(ctx->server, on_hook_ps_protocol_status);
 899         tcore_server_add_notification_hook(ctx->server,
 900                 TNOTI_PS_PROTOCOL_STATUS, on_hook_ps_protocol_status, ctx);
 901
 902         return TRUE;
 903 }
 904
 905 gboolean dbus_plugin_network_response(struct custom_data *ctx,
 906         UserRequest *ur, struct dbus_request_info *dbus_info,
 907         enum tcore_response_command command, unsigned int data_len, const void *data)
 908 {
 909         char *cpname = GET_CP_NAME(dbus_info->invocation);
 910
 911         switch (command) {
 912         case TRESP_NETWORK_SEARCH: {
 913                 const struct tresp_network_search *resp_network_search = data;
 914                 GVariant *network_search_result = NULL;
 915                 GVariantBuilder b;
 916                 int i = 0;
 917
 918                 info("[%s] NETWORK_SEARCH - [%s] Count: [%d]",
 919                         cpname, (resp_network_search->result == TCORE_RETURN_SUCCESS ? "Success" : "Fail"),
 920                         resp_network_search->list_count);
 921
 922                 g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
 923                 for (i = 0; i < resp_network_search->list_count; i++) {
 924                         g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
 925
 926                         g_variant_builder_add(&b, "{sv}", "plmn", g_variant_new_string(resp_network_search->list[i].plmn));
 927                         g_variant_builder_add(&b, "{sv}", "act", g_variant_new_int32(resp_network_search->list[i].act));
 928                         g_variant_builder_add(&b, "{sv}", "type", g_variant_new_int32(resp_network_search->list[i].status));
 929                         g_variant_builder_add(&b, "{sv}", "name", g_variant_new_string(resp_network_search->list[i].name));
 930
 931                         g_variant_builder_close(&b);
 932                 }
 933                 network_search_result = g_variant_builder_end(&b);
 934
 935                 telephony_network_complete_search(dbus_info->interface_object,
 936                         dbus_info->invocation,
 937                         network_search_result, resp_network_search->result);
 938         }
 939         break;
 940
 941         case TRESP_NETWORK_SET_PLMN_SELECTION_MODE: {
 942                 const struct tresp_network_set_plmn_selection_mode *resp_set_plmn_selection_mode = data;
 943
 944                 info("[%s] NETWORK_SET_PLMN_SELECTION_MODE - [%s]", cpname,
 945                         (resp_set_plmn_selection_mode->result == TCORE_RETURN_SUCCESS ? "Success" : "Fail"));
 946
 947                 telephony_network_complete_set_selection_mode(dbus_info->interface_object,
 948                         dbus_info->invocation, resp_set_plmn_selection_mode->result);
 949         }
 950         break;
 951
 952         case TRESP_NETWORK_GET_PLMN_SELECTION_MODE: {
 953                 const struct tresp_network_get_plmn_selection_mode *resp_get_plmn_selection_mode = data;
 954
 955                 info("[%s] NETWORK_GET_PLMN_SELECTION_MODE - [%s] Mode: [%s]", cpname,
 956                         (resp_get_plmn_selection_mode->result == TCORE_RETURN_SUCCESS ? "Success" : "Fail"),
 957                         (resp_get_plmn_selection_mode->mode == NETWORK_SELECT_MODE_AUTOMATIC ? "AUTO" :
 958                         (resp_get_plmn_selection_mode->mode == NETWORK_SELECT_MODE_MANUAL ? "MANUAL" :
 959                         "UNKNOWN")));
 960
 961                 switch (resp_get_plmn_selection_mode->mode) {
 962                 case NETWORK_SELECT_MODE_AUTOMATIC:
 963                         telephony_network_complete_get_selection_mode(dbus_info->interface_object,
 964                                 dbus_info->invocation, 0, resp_get_plmn_selection_mode->result);
 965                 break;
 966
 967                 case NETWORK_SELECT_MODE_MANUAL:
 968                         telephony_network_complete_get_selection_mode(dbus_info->interface_object,
 969                                 dbus_info->invocation, 1, resp_get_plmn_selection_mode->result);
 970                 break;
 971
 972                 default:
 973                         telephony_network_complete_get_selection_mode(dbus_info->interface_object,
 974                                 dbus_info->invocation, -1, resp_get_plmn_selection_mode->result);
 975                 break;
 976                 }
 977         }
 978         break;
 979
 980         case TRESP_NETWORK_SET_SERVICE_DOMAIN: {
 981                 const struct tresp_network_set_service_domain *resp_set_service_domain = data;
 982
 983                 dbg("[%s] NETWORK_SET_SERVICE_DOMAIN - [%s]", cpname,
 984                         (resp_set_service_domain->result == TCORE_RETURN_SUCCESS ? "Success" : "Fail"));
 985
 986                 telephony_network_complete_set_service_domain(dbus_info->interface_object,
 987                         dbus_info->invocation, resp_set_service_domain->result);
 988         }
 989         break;
 990
 991         case TRESP_NETWORK_GET_SERVICE_DOMAIN: {
 992                 const struct tresp_network_get_service_domain *resp_get_service_domain = data;
 993
 994                 dbg("[%s] NETWORK_GET_SERVICE_DOMAIN - [%s] Domain: [%d]", cpname,
 995                         (resp_get_service_domain->result == TCORE_RETURN_SUCCESS ? "Success" : "Fail"),
 996                         resp_get_service_domain->domain);
 997
 998                 telephony_network_complete_get_service_domain(dbus_info->interface_object,
 999                         dbus_info->invocation,
1000                         resp_get_service_domain->domain, resp_get_service_domain->result);
1001         }
1002         break;
1003
1004         case TRESP_NETWORK_SET_BAND: {
1005                 const struct tresp_network_set_band *resp_set_band = data;
1006
1007                 dbg("[%s] NETWORK_SET_BAND - [%s]", cpname,
1008                         (resp_set_band->result == TCORE_RETURN_SUCCESS ? "Success" : "Fail"));
1009
1010                 telephony_network_complete_set_band(dbus_info->interface_object,
1011                         dbus_info->invocation, resp_set_band->result);
1012         }
1013         break;
1014
1015         case TRESP_NETWORK_GET_BAND: {
1016                 const struct tresp_network_get_band *resp_get_band = data;
1017
1018                 dbg("[%s] NETWORK_GET_BAND - [%s] Mode: [%s] Band: [%d]", cpname,
1019                         (resp_get_band->result == TCORE_RETURN_SUCCESS ? "Success" : "Fail"),
1020                         (resp_get_band->mode == NETWORK_BAND_MODE_PREFERRED ? "PREFERRED" :
1021                         (resp_get_band->mode == NETWORK_BAND_MODE_ONLY ? "ONLY" :
1022                         "UNKNOWN")), resp_get_band->band);
1023
1024                 telephony_network_complete_get_band(dbus_info->interface_object,
1025                         dbus_info->invocation,
1026                         resp_get_band->band, resp_get_band->mode, resp_get_band->result);
1027         }
1028         break;
1029
1030         case TRESP_NETWORK_SET_MODE: {
1031                 const struct tresp_network_set_mode *resp_set_mode = data;
1032
1033                 dbg("[%s] NETWORK_SET_MODE - [%s]", cpname,
1034                         (resp_set_mode->result == TCORE_RETURN_SUCCESS ? "Success" : "Fail"));
1035
1036                 telephony_network_complete_set_mode(dbus_info->interface_object,
1037                         dbus_info->invocation, resp_set_mode->result);
1038         }
1039         break;
1040
1041         case TRESP_NETWORK_GET_MODE: {
1042                 const struct tresp_network_get_mode *resp_get_mode = data;
1043
1044                 dbg("[%s] NETWORK_GET_MODE - [%s] Mode: [%d]", cpname,
1045                         (resp_get_mode->result == TCORE_RETURN_SUCCESS ? "Success" : "Fail"),
1046                         resp_get_mode->mode);
1047
1048                 telephony_network_complete_get_mode(dbus_info->interface_object,
1049                         dbus_info->invocation,
1050                         resp_get_mode->mode, resp_get_mode->result);
1051         }
1052         break;
1053
1054         case TRESP_NETWORK_GET_NEIGHBORING_CELL_INFO: {
1055                 const struct tresp_network_get_neighboring_cell_info *resp_get_ngbr_cell_info = data;
1056                 GVariant *neighboring_cell_info_result = NULL;
1057                 GVariant *value = NULL;
1058                 GVariantBuilder b;
1059                 enum telephony_network_access_technology act;
1060                 int i = 0;
1061
1062                 dbg("[%s] NETWORK_GET_NEIGHBORING_CELL_INFO - [%s]", cpname,
1063                         (resp_get_ngbr_cell_info->result == TCORE_RETURN_SUCCESS ? "Success" : "Fail"));
1064
1065                 act = resp_get_ngbr_cell_info->info.serving.act;
1066
1067                 g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
1068
1069                 /*
1070                  * Fill Serving cell parameter
1071                  */
1072                 value = g_variant_new("(iii)",
1073                                 resp_get_ngbr_cell_info->info.serving.act,
1074                                 resp_get_ngbr_cell_info->info.serving.mcc,
1075                                 resp_get_ngbr_cell_info->info.serving.mnc);
1076                 g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
1077                 g_variant_builder_add(&b, "{sv}", "serving", value);
1078                 g_variant_builder_close(&b);
1079
1080                 if (act >= NETWORK_ACT_GSM && act <= NETWORK_ACT_EGPRS) {
1081                         value = g_variant_new("(iiiii)",
1082                                 resp_get_ngbr_cell_info->info.serving.cell.geran.cell_id,
1083                                 resp_get_ngbr_cell_info->info.serving.cell.geran.lac,
1084                                 resp_get_ngbr_cell_info->info.serving.cell.geran.bcch,
1085                                 resp_get_ngbr_cell_info->info.serving.cell.geran.bsic,
1086                                 resp_get_ngbr_cell_info->info.serving.cell.geran.rxlev);
1087                         g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
1088                         g_variant_builder_add(&b, "{sv}", "g_serving", value);
1089                         g_variant_builder_close(&b);
1090                 } else if (act >= NETWORK_ACT_UMTS && act <= NETWORK_ACT_GSM_UTRAN) {
1091                         value = g_variant_new("(iiiii)",
1092                                 resp_get_ngbr_cell_info->info.serving.cell.umts.cell_id,
1093                                 resp_get_ngbr_cell_info->info.serving.cell.umts.lac,
1094                                 resp_get_ngbr_cell_info->info.serving.cell.umts.arfcn,
1095                                 resp_get_ngbr_cell_info->info.serving.cell.umts.psc,
1096                                 resp_get_ngbr_cell_info->info.serving.cell.umts.rscp);
1097                         g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
1098                         g_variant_builder_add(&b, "{sv}", "u_serving", value);
1099                         g_variant_builder_close(&b);
1100                 } else if (act == NETWORK_ACT_LTE) {
1101                         value = g_variant_new("(iiiii)",
1102                                 resp_get_ngbr_cell_info->info.serving.cell.lte.cell_id,
1103                                 resp_get_ngbr_cell_info->info.serving.cell.lte.lac,
1104                                 resp_get_ngbr_cell_info->info.serving.cell.lte.earfcn,
1105                                 resp_get_ngbr_cell_info->info.serving.cell.lte.tac,
1106                                 resp_get_ngbr_cell_info->info.serving.cell.lte.rssi);
1107                         g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
1108                         g_variant_builder_add(&b, "{sv}", "l_serving", value);
1109                         g_variant_builder_close(&b);
1110                 } else if (act >= NETWORK_ACT_IS95A && act <= NETWORK_ACT_EHRPD) {
1111                         value = g_variant_new("(uuuuii)",
1112                                 resp_get_ngbr_cell_info->info.serving.cell.cdma.sid,
1113                                 resp_get_ngbr_cell_info->info.serving.cell.cdma.nid,
1114                                 resp_get_ngbr_cell_info->info.serving.cell.cdma.base_id,
1115                                 resp_get_ngbr_cell_info->info.serving.cell.cdma.refpn,
1116                                 resp_get_ngbr_cell_info->info.serving.cell.cdma.base_lat,
1117                                 resp_get_ngbr_cell_info->info.serving.cell.cdma.base_long);
1118                         g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
1119                         g_variant_builder_add(&b, "{sv}", "c_serving", value);
1120                         g_variant_builder_close(&b);
1121                 }
1122
1123                 /*
1124                  * Fill GERAN neighbor cell parameter
1125                  */
1126                 for (i = 0; i < resp_get_ngbr_cell_info->info.geran_list_count; i++) {
1127                         value = g_variant_new("(iiiii)",
1128                                 resp_get_ngbr_cell_info->info.geran_list[i].cell_id,
1129                                 resp_get_ngbr_cell_info->info.geran_list[i].lac,
1130                                 resp_get_ngbr_cell_info->info.geran_list[i].bcch,
1131                                 resp_get_ngbr_cell_info->info.geran_list[i].bsic,
1132                                 resp_get_ngbr_cell_info->info.geran_list[i].rxlev);
1133                         g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
1134                         g_variant_builder_add(&b, "{sv}", "geran", value);
1135                         g_variant_builder_close(&b);
1136                 }
1137
1138                 /*
1139                  * Fill UMTS neighbor cell parameter
1140                  */
1141                 for (i = 0; i < resp_get_ngbr_cell_info->info.umts_list_count; i++) {
1142                         value = g_variant_new("(iiiii)",
1143                                 resp_get_ngbr_cell_info->info.umts_list[i].cell_id,
1144                                 resp_get_ngbr_cell_info->info.umts_list[i].lac,
1145                                 resp_get_ngbr_cell_info->info.umts_list[i].arfcn,
1146                                 resp_get_ngbr_cell_info->info.umts_list[i].psc,
1147                                 resp_get_ngbr_cell_info->info.umts_list[i].rscp);
1148                         g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
1149                         g_variant_builder_add(&b, "{sv}", "umts", value);
1150                         g_variant_builder_close(&b);
1151                 }
1152                 neighboring_cell_info_result = g_variant_builder_end(&b);
1153
1154                 telephony_network_complete_get_ngbr_cell_info(dbus_info->interface_object,
1155                         dbus_info->invocation,
1156                         neighboring_cell_info_result, resp_get_ngbr_cell_info->result);
1157         }
1158         break;
1159
1160         case TRESP_NETWORK_SET_PREFERRED_PLMN: {
1161                 const struct tresp_network_set_preferred_plmn *resp_set_preferred_plmn = data;
1162
1163                 dbg("[%s] NETWORK_SET_PREFERRED_PLMN - [%s]", cpname,
1164                         (resp_set_preferred_plmn->result == TCORE_RETURN_SUCCESS ? "Success" : "Fail"));
1165
1166                 telephony_network_complete_set_preferred_plmn(dbus_info->interface_object,
1167                         dbus_info->invocation, resp_set_preferred_plmn->result);
1168         }
1169         break;
1170
1171         case TRESP_NETWORK_GET_PREFERRED_PLMN: {
1172                 const struct tresp_network_get_preferred_plmn *resp_get_preferred_plmn = data;
1173                 GVariant *preferred_plmn_result = NULL;
1174                 GVariantBuilder b;
1175                 int i = 0;
1176
1177                 dbg("[%s] NETWORK_GET_PREFERRED_PLMN - [%s] Count: [%d]", cpname,
1178                         (resp_get_preferred_plmn->result == TCORE_RETURN_SUCCESS ? "Success" : "Fail"),
1179                         resp_get_preferred_plmn->list_count);
1180
1181                 g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
1182                 for (i = 0; i < resp_get_preferred_plmn->list_count; i++) {
1183                         g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
1184
1185                         g_variant_builder_add(&b, "{sv}", "plmn",
1186                                 g_variant_new_string(resp_get_preferred_plmn->list[i].plmn));
1187                         g_variant_builder_add(&b, "{sv}", "act",
1188                                 g_variant_new_int32(resp_get_preferred_plmn->list[i].act));
1189                         g_variant_builder_add(&b, "{sv}", "index",
1190                                 g_variant_new_int32(resp_get_preferred_plmn->list[i].ef_index));
1191                         g_variant_builder_add(&b, "{sv}", "name",
1192                                 g_variant_new_string(resp_get_preferred_plmn->list[i].name));
1193
1194                         g_variant_builder_close(&b);
1195                 }
1196                 preferred_plmn_result = g_variant_builder_end(&b);
1197
1198                 telephony_network_complete_get_preferred_plmn(dbus_info->interface_object,
1199                         dbus_info->invocation,
1200                         preferred_plmn_result, resp_get_preferred_plmn->result);
1201         }
1202         break;
1203
1204         case TRESP_NETWORK_SET_CANCEL_MANUAL_SEARCH: {
1205                 const struct tresp_network_set_cancel_manual_search *resp_set_cancel_manual_search = data;
1206
1207                 info("[%s] NETWORK_SET_CANCEL_MANUAL_SEARCH - [%s]", cpname,
1208                         (resp_set_cancel_manual_search->result == TCORE_RETURN_SUCCESS ? "Success" : "Fail"));
1209
1210                 telephony_network_complete_search_cancel(dbus_info->interface_object,
1211                         dbus_info->invocation, resp_set_cancel_manual_search->result);
1212         }
1213         break;
1214
1215         case TRESP_NETWORK_GET_SERVING_NETWORK: {
1216                 const struct tresp_network_get_serving_network *resp_get_serving_network = data;
1217                 GVariant *serving_network = NULL;
1218                 GVariant *value = NULL;
1219                 GVariantBuilder b;
1220
1221                 enum telephony_network_access_technology act;
1222
1223                 dbg("[%s] NETWORK_GET_SERVING_NETWORK - [%s] AcT: [%d] PLMN: [%s] LAC: [%d]", cpname,
1224                         (resp_get_serving_network->result == TCORE_RETURN_SUCCESS ? "Success" : "Fail"),
1225                         resp_get_serving_network->act, resp_get_serving_network->plmn,
1226                         resp_get_serving_network->gsm.lac);
1227
1228                 act = resp_get_serving_network->act;
1229                 g_variant_builder_init(&b, G_VARIANT_TYPE("a{sv}"));
1230
1231                 /*
1232                  * Fill Serving cell parameter
1233                  */
1234                 value = g_variant_new("(is)",
1235                         resp_get_serving_network->act,
1236                         resp_get_serving_network->plmn);
1237
1238                 g_variant_builder_add(&b, "{sv}", "serving", value);
1239                 if ((act >= NETWORK_ACT_GSM
1240                                 && act <= NETWORK_ACT_GSM_UTRAN)
1241                                 || act == NETWORK_ACT_LTE) {
1242                         dbg("lac: [%d]", resp_get_serving_network->gsm.lac);
1243
1244                         value = g_variant_new("(i)",
1245                                 resp_get_serving_network->gsm.lac);
1246                         g_variant_builder_add(&b, "{sv}", "g_serving", value);
1247                 } else if (act >= NETWORK_ACT_IS95A
1248                                 && act <= NETWORK_ACT_EHRPD) {
1249                         dbg("carrier: [%d] sid: [%d] nid: [%d] bs_id: [%d] " \
1250                                 "bs_lat: [%d] bs_long: [%d] reg_zone: [%d] pilot_pn: [%d]",
1251                                 resp_get_serving_network->cdma.carrier,
1252                                 resp_get_serving_network->cdma.sid,
1253                                 resp_get_serving_network->cdma.nid,
1254                                 resp_get_serving_network->cdma.bs_id,
1255                                 resp_get_serving_network->cdma.bs_lat,
1256                                 resp_get_serving_network->cdma.bs_long,
1257                                 resp_get_serving_network->cdma.reg_zone,
1258                                 resp_get_serving_network->cdma.pilot_pn);
1259
1260                         value = g_variant_new("(iuuuiiuu)",
1261                                 resp_get_serving_network->cdma.carrier,
1262                                 resp_get_serving_network->cdma.sid,
1263                                 resp_get_serving_network->cdma.nid,
1264                                 resp_get_serving_network->cdma.bs_id,
1265                                 resp_get_serving_network->cdma.bs_lat,
1266                                 resp_get_serving_network->cdma.bs_long,
1267                                 resp_get_serving_network->cdma.reg_zone,
1268                                 resp_get_serving_network->cdma.pilot_pn);
1269                         g_variant_builder_add(&b, "{sv}", "c_serving", value);
1270                 }
1271                 serving_network = g_variant_builder_end(&b);
1272
1273                 telephony_network_complete_get_serving_network(dbus_info->interface_object,
1274                         dbus_info->invocation,
1275                         serving_network, resp_get_serving_network->result);
1276         }
1277         break;
1278
1279         case TRESP_NETWORK_SET_DEFAULT_DATA_SUBSCRIPTION: {
1280                 const struct tresp_network_set_default_data_subscription *resp_set_default_data_subs = data;
1281
1282                 info("[%s] NETWORK_SET_DEFAULT_DATA_SUBSCRIPTION - [%s]", cpname,
1283                         (resp_set_default_data_subs->result == TCORE_RETURN_SUCCESS ? "Success" : "Fail"));
1284
1285                 telephony_network_complete_set_default_data_subscription(dbus_info->interface_object,
1286                         dbus_info->invocation, resp_set_default_data_subs->result);
1287         }
1288         break;
1289
1290         case TRESP_NETWORK_GET_DEFAULT_DATA_SUBSCRIPTION: {
1291                 const struct tresp_network_get_default_data_subs *resp_get_default_data_subs = data;
1292
1293                 dbg("[%s] NETWORK_GET_DEFAULT_DATA_SUBSCRIPTION - [%s] 'default' Data subscription: [%s]", cpname,
1294                         (resp_get_default_data_subs->result == TCORE_RETURN_SUCCESS ? "Success" : "Fail"),
1295                         (resp_get_default_data_subs->default_subs == NETWORK_DEFAULT_DATA_SUBS_SIM1 ? "SIM 1" :
1296                         (resp_get_default_data_subs->default_subs == NETWORK_DEFAULT_DATA_SUBS_SIM2 ? "SIM 2" :
1297                         "UNKNWON")));
1298
1299                 telephony_network_complete_get_default_data_subscription(dbus_info->interface_object, dbus_info->invocation,
1300                         resp_get_default_data_subs->default_subs, resp_get_default_data_subs->result);
1301         }
1302         break;
1303
1304         case TRESP_NETWORK_SET_DEFAULT_SUBSCRIPTION: {
1305                 const struct tresp_network_set_default_subs *resp_set_default_subs = data;
1306
1307                 info("[%s] NETWORK_SET_DEFAULT_SUBSCRIPTION - [%s]", cpname,
1308                         (resp_set_default_subs->result == TCORE_RETURN_SUCCESS ? "Success" : "Fail"));
1309
1310                 telephony_network_complete_set_default_subscription(dbus_info->interface_object,
1311                         dbus_info->invocation, resp_set_default_subs->result);
1312         }
1313         break;
1314
1315         case TRESP_NETWORK_GET_DEFAULT_SUBSCRIPTION: {
1316                 const struct tresp_network_get_default_subs *resp_get_default_subs = data;
1317
1318                 dbg("[%s] NETWORK_GET_DEFAULT_SUBSCRIPTION - [%s] 'default' subscription: [%s]", cpname,
1319                         (resp_get_default_subs->result == TCORE_RETURN_SUCCESS ? "Success" : "Fail"),
1320                         (resp_get_default_subs->default_subs == NETWORK_DEFAULT_SUBS_SIM1 ? "SIM 1" :
1321                         (resp_get_default_subs->default_subs == NETWORK_DEFAULT_SUBS_SIM2 ? "SIM 2" :
1322                         "UNKNOWN")));
1323
1324                 telephony_network_complete_get_default_subscription(dbus_info->interface_object,
1325                         dbus_info->invocation,
1326                         resp_get_default_subs->default_subs, resp_get_default_subs->result);
1327         }
1328         break;
1329
1330         case TRESP_NETWORK_SET_EMERGENCY_CALLBACK_MODE: {
1331                 const struct tresp_network_set_emergency_callback_mode *resp_set_emergency_callback_mode = data;
1332
1333                 info("[%s] NETWORK_SET_EMERGENCY_CALLBACK_MODE - [%s]", cpname,
1334                         (resp_set_emergency_callback_mode->result == TCORE_RETURN_SUCCESS ? "Success" : "Fail"));
1335
1336                 telephony_network_complete_set_emergency_callback_mode(dbus_info->interface_object,
1337                         dbus_info->invocation, resp_set_emergency_callback_mode->result);
1338         }
1339         break;
1340
1341         case TRESP_NETWORK_SET_ROAMING_PREFERENCE: {
1342                 const struct tresp_network_set_roaming_preference *resp_set_roam_pref = data;
1343
1344                 info("[%s] NETWORK_SET_ROAMING_PREFERENCE - [%s]", cpname,
1345                         (resp_set_roam_pref->result == TCORE_RETURN_SUCCESS ? "Success" : "Fail"));
1346
1347                 telephony_network_complete_set_roaming_preference(dbus_info->interface_object,
1348                         dbus_info->invocation, resp_set_roam_pref->result);
1349         }
1350         break;
1351
1352         case TRESP_NETWORK_GET_ROAMING_PREFERENCE: {
1353                 const struct tresp_network_get_roaming_preference *resp_get_roam_pref = data;
1354
1355                 dbg("[%s] NETWORK_GET_ROAMING_PREFERENCE - [%s] roam_pref: [%d]", cpname,
1356                         (resp_get_roam_pref->result == TCORE_RETURN_SUCCESS ? "Success" : "Fail"),
1357                         resp_get_roam_pref->roam_pref);
1358
1359                 telephony_network_complete_get_roaming_preference(dbus_info->interface_object,
1360                         dbus_info->invocation,
1361                         resp_get_roam_pref->roam_pref, resp_get_roam_pref->result);
1362         }
1363         break;
1364
1365         default:
1366                 err("Unhandled/Unknown Response: [0x%x]", command);
1367         break;
1368         }
1369
1370         return TRUE;
1371 }
1372
1373 gboolean dbus_plugin_network_notification(struct custom_data *ctx,
1374         CoreObject *source, TelephonyObjectSkeleton *object,
1375         enum tcore_notification_command command, unsigned int data_len, const void *data)
1376 {
1377         TelephonyNetwork *network;
1378         const char *cp_name;
1379
1380         if (!object) {
1381                 err("object is NULL");
1382                 return FALSE;
1383         }
1384
1385         if (!data) {
1386                 err("data is NULL");
1387                 return FALSE;
1388         }
1389
1390         cp_name = tcore_server_get_cp_name_by_plugin(tcore_object_ref_plugin(source));
1391         network = telephony_object_peek_network(TELEPHONY_OBJECT(object));
1392         if (network == NULL) {
1393                 err("Network object is NULL!!!");
1394                 return FALSE;
1395         }
1396
1397         switch (command) {
1398         case TNOTI_NETWORK_REGISTRATION_STATUS: {
1399                 const struct tnoti_network_registration_status *reg = data;
1400
1401                 info("[%s] NET_REGI_STATUS - CS: [%d] PS: [%d] SVC: [%d] Roam: [%d]", cp_name,
1402                         reg->cs_domain_status, reg->ps_domain_status,
1403                         reg->service_type, reg->roaming_status);
1404
1405 #ifdef ENABLE_KPI_LOGS
1406                 /* We ignore No SIM present case for KPI */
1407                 if (reg->cs_domain_status == NETWORK_SERVICE_DOMAIN_STATUS_FULL
1408                         && telephony_network_get_circuit_status(network) != NETWORK_SERVICE_DOMAIN_STATUS_FULL)
1409                         TIME_CHECK("[%s] CS Network Full", cp_name);
1410
1411                 if (reg->ps_domain_status == NETWORK_SERVICE_DOMAIN_STATUS_FULL
1412                         && telephony_network_get_packet_status(network) != NETWORK_SERVICE_DOMAIN_STATUS_FULL)
1413                         TIME_CHECK("[%s] PS Network Full", cp_name);
1414 #endif
1415                 __check_network_properties(network, source, cp_name,
1416                                 (NET_PROP_CS|NET_PROP_PS|NET_PROP_SVC_TYPE|NET_PROP_ROAM));
1417
1418                 /* Emit Signal */
1419                 telephony_network_emit_registration_status(network,
1420                         reg->cs_domain_status, reg->ps_domain_status,
1421                         reg->service_type, reg->roaming_status);
1422         }
1423         break;
1424
1425         case TNOTI_NETWORK_CHANGE: {
1426                 const struct tnoti_network_change *change = data;
1427
1428                 info("[%s] NET_CHANGE - plmn: [%s] lac: [%d]", cp_name,
1429                         change->plmn, change->gsm.lac);
1430
1431                 __check_network_properties(network, source, cp_name, NET_PROP_PLMN);
1432
1433                 /* Emit Signal */
1434                 telephony_network_emit_change(network,
1435                         change->act, change->plmn);
1436         }
1437         break;
1438
1439         case TNOTI_NETWORK_TIMEINFO: {
1440                 const struct tnoti_network_timeinfo *time_info = data;
1441
1442                 info("[%s] NET_TIMEINFO - [%04d-%02d-%02d] [%02d:%02d:%02d]", cp_name,
1443                         time_info->year, time_info->month, time_info->day,
1444                         time_info->hour, time_info->minute, time_info->second);
1445
1446                 /* Emit signal */
1447                 telephony_network_emit_time_info(network,
1448                         time_info->year, time_info->month, time_info->day,
1449                         time_info->hour, time_info->minute, time_info->second,
1450                         time_info->wday,
1451                         time_info->gmtoff, time_info->dstoff,
1452                         time_info->isdst,
1453                         time_info->plmn);
1454         }
1455         break;
1456
1457         case TNOTI_NETWORK_ICON_INFO: {
1458                 const struct tnoti_network_icon_info *icon_info = data;
1459
1460                 /* Update property */
1461                 if (icon_info->type & NETWORK_ICON_INFO_RSSI) {
1462                         info("[%s] NET_ICON_INFO - RSSI: [%d]", cp_name, icon_info->rssi);
1463
1464                         /* Emit signal */
1465                         telephony_network_set_sig_level(network, icon_info->rssi);
1466                 }
1467         }
1468         break;
1469
1470         case TNOTI_NETWORK_IDENTITY: {
1471                 const struct tnoti_network_identity *identity = data;
1472
1473                 info("[%s] NET_IDENTITY - long name: [%s] short name: [%s] PLMN: [%s]", cp_name,
1474                         identity->full_name, identity->short_name, identity->plmn);
1475
1476                 __check_network_properties(network, source, cp_name,
1477                         (NET_PROP_NAME_OPTION | NET_PROP_SPN | NET_PROP_NWNAME));
1478
1479                 /* Emit Signal */
1480                 telephony_network_emit_identity(network,
1481                         identity->plmn, identity->short_name, identity->full_name);
1482         }
1483         break;
1484
1485         case TNOTI_NETWORK_LOCATION_CELLINFO: {
1486                 const struct tnoti_network_location_cellinfo *location = data;
1487                 enum telephony_network_service_type network_service_type = NETWORK_SERVICE_TYPE_UNKNOWN;
1488
1489                 info("[%s] NET_LOCATION_CELLINFO - LAC: [0x%x] Cell ID: [0x%x]", cp_name,
1490                         location->lac, location->cell_id);
1491
1492                 /* Update properties */
1493                 tcore_network_get_service_type(source, &network_service_type);
1494                 if (NETWORK_SERVICE_TYPE_LTE == network_service_type) {
1495                         telephony_network_set_lac(network, 0);
1496                         telephony_network_set_tac(network, location->lac);
1497                 } else {
1498                         telephony_network_set_lac(network, location->lac);
1499                         telephony_network_set_tac(network, 0);
1500                 }
1501
1502                 telephony_network_set_cell_id(network, location->cell_id);
1503
1504                 /* Emit signal */
1505                 telephony_network_emit_cell_info(network,
1506                         location->lac, location->cell_id);
1507         }
1508         break;
1509
1510         case TNOTI_NETWORK_SIGNAL_STRENGTH: {
1511                 const struct tnoti_network_signal_strength *signal_strength = data;
1512
1513                 info("[%s] NET_SIGNAL_STRENGTH - DBM: [%d]", cp_name,
1514                         signal_strength->dbm);
1515
1516                 /* Update properties */
1517                 telephony_network_set_sig_dbm(network, signal_strength->dbm);
1518
1519                 /* Emit signal */
1520                 telephony_network_emit_signal_strength(network,
1521                         signal_strength->dbm);
1522         }
1523         break;
1524
1525         case TNOTI_NETWORK_DEFAULT_DATA_SUBSCRIPTION: {
1526                 const struct tnoti_network_default_data_subs *default_data_subs_info = data;
1527
1528                 info("[%s] NET_DEFAULT_DATA_SUBSCRIPTION - 'default' DDS: [%s]", cp_name,
1529                         (default_data_subs_info->default_subs == NETWORK_DEFAULT_DATA_SUBS_SIM1 ? "SIM 1" :
1530                         (default_data_subs_info->default_subs == NETWORK_DEFAULT_DATA_SUBS_SIM2 ? "SIM 2" :
1531                         "UNKNOWN")));
1532
1533                 /* Emit signal */
1534                 telephony_network_emit_default_data_subscription(network,
1535                         default_data_subs_info->default_subs);
1536         }
1537         break;
1538
1539         case TNOTI_NETWORK_DEFAULT_SUBSCRIPTION: {
1540                 const struct tnoti_network_default_subs *default_subs_info = data;
1541
1542                 info("[%s] NET_DEFAULT_SUBSCRIPTION - 'default' subscription: [%s]", cp_name,
1543                         (default_subs_info->default_subs == NETWORK_DEFAULT_SUBS_SIM1 ? "SIM 1" :
1544                         (default_subs_info->default_subs == NETWORK_DEFAULT_SUBS_SIM2 ? "SIM 2" :
1545                         "UNKNOWN")));
1546
1547                 /* Emit signal */
1548                 telephony_network_emit_default_subscription(network,
1549                         default_subs_info->default_subs);
1550         }
1551         break;
1552
1553         case TNOTI_NETWORK_IMS_VOICE_SUPPORT_STATUS: {
1554                 const struct tnoti_network_ims_voice_status *status = data;
1555
1556                 dbg("[%s] NET_IMS_VOICE_SUPPORT_STATUS - Status: [%s]", cp_name,
1557                         (status->status == NETWORK_IMS_VOICE_SUPPORT ? "SUPPORTED" :
1558                         (status->status == NETWORK_IMS_VOICE_NOT_SUPPORT ? "NOT SUPPORTED" :
1559                         "UNKNOWN")));
1560
1561                 /* Update properties */
1562                 telephony_network_set_ims_voice_status(network,
1563                         status->status);
1564         }
1565         break;
1566
1567         case TNOTI_NETWORK_EMERGENCY_CALLBACK_MODE: {
1568                 const struct tnoti_network_emergency_callback_mode *emergency_callback_mode = data;
1569
1570                 dbg("[%s] NET_EMERGENCY_CALLBACK_MODE - Mode: [%s]", cp_name,
1571                         (emergency_callback_mode->mode == NETWORK_EMERGENCY_CALLBACK_MODE_ENTER ? "ENTER" :
1572                         (emergency_callback_mode->mode == NETWORK_EMERGENCY_CALLBACK_MODE_EXIT? "EXIT" :
1573                         "READY")));
1574
1575                 /* Emit signal */
1576                 telephony_network_emit_emergency_callback_mode(network,
1577                         emergency_callback_mode->mode);
1578         }
1579         break;
1580
1581         case TNOTI_NETWORK_IMS_REGISTRATION_STATUS: {
1582                 const struct tnoti_network_ims_registration_info *ims_reg_info = data;
1583
1584                 dbg("TNOTI_NETWORK_IMS_REGISTRATION_STATUS");
1585
1586                 if (ims_reg_info->is_registered
1587                                 && (ims_reg_info->feature_mask & NETWORK_IMS_REG_FEATURE_TYPE_VOLTE)) {
1588                         telephony_network_set_volte_enable(network, TRUE);
1589                 } else {
1590                         telephony_network_set_volte_enable(network, FALSE);
1591                 }
1592         }
1593         break;
1594
1595         default:
1596                 err("Unhandled/Unknown Notification: [0x%x]", command);
1597         break;
1598         }
1599
1600         return TRUE;
1601 }
1602
1603