src/service.c

   1 /*
   2  * PacketService Control Module
   3  *
   4  * Copyright (c) 2012 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: DongHoo Park <donghoo.park@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
  22 #include "ps-service.h"
  23
  24 #include "ps.h"
  25 #include "ps-error.h"
  26
  27 #include <core_object.h>
  28 #include <co_ps.h>
  29
  30 #define PROP_DEFAULT    FALSE
  31 #define PROP_DEFAULT_STR   NULL
  32 #define BOOL2STRING(a)  ((a==TRUE) ? ("TRUE"):("FALSE"))
  33
  34 #define TIMEOUT_DEFAULT         5
  35 #define TIMEOUT_MAX                     1280
  36
  37 guint connection_timeout;
  38 guint timer_src;
  39
  40 /*Properties*/
  41
  42 enum {
  43         PROP_SERVICE_O,
  44
  45         PROP_SERVICE_PATH,
  46         PROP_SERVICE_PLUGIN,
  47         PROP_SERVICE_CONN,
  48         PROP_SERVICE_P_MODEM,
  49         PROP_SERVICE_CO_NETWORK,
  50         PROP_SERVICE_CO_PS
  51 };
  52
  53 enum {
  54         SIG_SERVICE_CONTEXT_ADDED,
  55         SIG_SERVICE_CONTEXT_REMOVED,
  56         SIG_SERVICE_PROPERTY_CHANGED,
  57         SIG_SERVICE_LAST
  58 };
  59
  60 static guint32 signals[SIG_SERVICE_LAST] = {0,};
  61
  62 struct PsServiceClass {
  63         GObjectClass parent;
  64
  65         //method and signals
  66         void (*context_added)(PsService *service, gchar *context_path);
  67         void (*context_removed)(PsService *service, gchar *context_path);
  68         void (*property_changed)(PsService *service, GHashTable *service_property);
  69 };
  70
  71 struct PsService {
  72         GObject parent;
  73
  74         gchar *path;
  75         TcorePlugin *plg;
  76         DBusGConnection *conn;
  77         gpointer p_modem;
  78         CoreObject *co_network;
  79         CoreObject *co_ps;
  80
  81         gboolean ps_attached;
  82         gboolean roaming;
  83         enum telephony_network_access_technology act;
  84
  85         GHashTable *contexts;
  86 };
  87
  88 G_DEFINE_TYPE(PsService, ps_service, G_TYPE_OBJECT);
  89
  90 /*Function Declaration*/
  91 static void __ps_service_get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
  92 static void __ps_service_set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
  93
  94 gboolean ps_iface_service_get_properties(PsService *service, DBusGMethodInvocation *context);
  95 gboolean ps_iface_service_get_contexts(PsService *service, DBusGMethodInvocation *context);
  96
  97 static void __ps_service_emit_property_changed_signal(PsService *service);
  98 static void __ps_service_emit_context_added_signal(PsService *service, gpointer context);
  99 static void __ps_service_emit_context_removed_signal(PsService *service, gpointer context);
 100
 101 static void __remove_context(gpointer data);
 102 static char *__ps_service_act2string(enum telephony_network_access_technology act);
 103 static gboolean __ps_service_check_connection_option(gpointer service);
 104 static gboolean __ps_service_connetion_timeout_handler(gpointer user_data);
 105
 106 #include "ps-iface-service-glue.h"
 107
 108 static void ps_service_init(PsService *service)
 109 {
 110         dbg("service initialize");
 111
 112         service->path = PROP_DEFAULT_STR;
 113         service->plg = NULL;
 114         service->conn = NULL;
 115         service->p_modem = NULL;
 116         service->co_network = NULL;
 117         service->co_ps = NULL;
 118
 119         service->ps_attached = PROP_DEFAULT;
 120         service->roaming = PROP_DEFAULT;
 121         service->act = NETWORK_ACT_UNKNOWN;
 122
 123         service->contexts = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, __remove_context);
 124         return;
 125 }
 126
 127 static void ps_service_class_init(PsServiceClass *klass)
 128 {
 129         GObjectClass *object_class = G_OBJECT_CLASS(klass);
 130
 131         //class init
 132         dbg("class init");
 133
 134         object_class->get_property = __ps_service_get_property;
 135         object_class->set_property = __ps_service_set_property;
 136
 137         //dbus register
 138         dbus_g_object_type_install_info(PS_TYPE_SERVICE, &dbus_glib_ps_iface_service_object_info);
 139
 140         //add properties
 141         g_object_class_install_property(
 142                         object_class,
 143                         PROP_SERVICE_PATH,
 144                         g_param_spec_string("path", "PATH", "Technology Path", NULL,
 145                                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 146
 147         g_object_class_install_property(
 148                         object_class,
 149                         PROP_SERVICE_P_MODEM,
 150                         g_param_spec_pointer("p_modem", "MODEM", "Parent Modem Object",
 151                                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 152
 153         g_object_class_install_property(
 154                         object_class,
 155                         PROP_SERVICE_PLUGIN,
 156                         g_param_spec_pointer("plg", "PLUGIN", "Plug in Object",
 157                                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 158
 159         g_object_class_install_property(
 160                         object_class,
 161                         PROP_SERVICE_CO_NETWORK,
 162                         g_param_spec_pointer("co_network", "COREOBJECT NETWORK", "CoreObject of Network",
 163                                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 164
 165         g_object_class_install_property(
 166                         object_class,
 167                         PROP_SERVICE_CO_PS,
 168                         g_param_spec_pointer("co_ps", "COREOBJECTPS", "CoreObject of PS",
 169                                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 170
 171         g_object_class_install_property(
 172                         object_class,
 173                         PROP_SERVICE_CONN,
 174                         g_param_spec_boxed("conn", "CONNECTION", "DBus connection", DBUS_TYPE_G_CONNECTION,
 175                                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 176
 177         //add signal handler
 178         signals[SIG_SERVICE_CONTEXT_ADDED] = g_signal_new("context-added", G_OBJECT_CLASS_TYPE(klass),
 179                         G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET(PsServiceClass, context_added), NULL, NULL,
 180                         g_cclosure_marshal_VOID__BOXED, G_TYPE_NONE, 1, DBUS_TYPE_G_STRING_STRING_HASHTABLE);
 181
 182         signals[SIG_SERVICE_CONTEXT_REMOVED] = g_signal_new("context-removed",
 183                         G_OBJECT_CLASS_TYPE(klass), G_SIGNAL_RUN_LAST,
 184                         G_STRUCT_OFFSET(PsServiceClass, context_removed), NULL, NULL,
 185                         g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, DBUS_TYPE_G_OBJECT_PATH);
 186
 187         signals[SIG_SERVICE_PROPERTY_CHANGED] = g_signal_new("property-changed",
 188                         G_OBJECT_CLASS_TYPE(klass), G_SIGNAL_RUN_LAST,
 189                         G_STRUCT_OFFSET(PsServiceClass, property_changed), NULL, NULL,
 190                         g_cclosure_marshal_VOID__BOXED, G_TYPE_NONE, 1, DBUS_TYPE_G_STRING_STRING_HASHTABLE);
 191
 192         return;
 193 }
 194
 195 static void __ps_service_get_property(GObject *object, guint prop_id, GValue *value,
 196                 GParamSpec *pspec)
 197 {
 198         return;
 199 }
 200
 201 static void __ps_service_set_property(GObject *object, guint prop_id, const GValue *value,
 202                 GParamSpec *pspec)
 203 {
 204         PsService *service = PS_SERVICE(object);
 205
 206         switch (prop_id) {
 207                 case PROP_SERVICE_PATH: {
 208                         if (service->path) g_free(service->path);
 209                         service->path = g_value_dup_string(value);
 210                         msg("service(%p) set path(%s)", service, service->path);
 211                 }
 212                         break;
 213                 case PROP_SERVICE_P_MODEM: {
 214                         service->p_modem = g_value_get_pointer(value);
 215                         msg("service(%p) set modem(%p)", service, service->p_modem);
 216                 }
 217                         break;
 218                 case PROP_SERVICE_PLUGIN: {
 219                         service->plg = g_value_get_pointer(value);
 220                         msg("service(%p) set plg(%p)", service, service->plg);
 221                 }
 222                         break;
 223                 case PROP_SERVICE_CO_NETWORK: {
 224                         service->co_network = g_value_get_pointer(value);
 225                         msg("service(%p) set co_network(%p)", service, service->co_network);
 226                 }
 227                         break;
 228                 case PROP_SERVICE_CO_PS: {
 229                         service->co_ps = g_value_get_pointer(value);
 230                         msg("service(%p) set co_ps(%p)", service, service->co_ps);
 231                 }
 232                         break;
 233                 case PROP_SERVICE_CONN: {
 234                         service->conn = g_value_get_boxed(value);
 235                         msg("service(%p) set conn(%p)", service, service->conn);
 236                 }
 237                         break;
 238                 default:
 239                         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 240                         break;
 241         } //swtich end
 242
 243         return;
 244 }
 245
 246 gboolean ps_iface_service_get_properties(PsService *service, DBusGMethodInvocation *context)
 247 {
 248         GError *error;
 249         gboolean rv = FALSE;
 250         GHashTable *properties = NULL;
 251
 252         dbg("get service properties");
 253
 254         properties = g_hash_table_new(g_str_hash, g_str_equal);
 255         rv = _ps_service_get_properties(service, properties);
 256         if (rv != TRUE) {
 257                 g_set_error(&error, PS_ERROR, PS_ERR_INTERNAL, "fail to get properties service(%p)",
 258                                 service);
 259                 dbus_g_method_return_error(context, error);
 260                 g_hash_table_destroy(properties);
 261                 return FALSE;
 262         }
 263
 264         dbus_g_method_return(context, properties);
 265         g_hash_table_destroy(properties);
 266         return TRUE;
 267 }
 268
 269 gboolean ps_iface_service_get_contexts(PsService *service, DBusGMethodInvocation *context)
 270 {
 271         GError *error;
 272         GHashTableIter iter;
 273         gpointer key, value;
 274         GHashTable *contexts;
 275
 276         dbg("service get contexts interface");
 277
 278         if (service->contexts == NULL) {
 279                 g_set_error(&error, PS_ERROR, PS_ERR_INTERNAL, "service(%p) does not have contexts",
 280                                 service);
 281                 dbus_g_method_return_error(context, error);
 282                 return FALSE;
 283         }
 284
 285         contexts = g_hash_table_new_full(g_direct_hash, g_str_equal, g_free,
 286                         (GDestroyNotify) g_hash_table_destroy);
 287
 288         g_hash_table_iter_init(&iter, service->contexts);
 289         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 290                 gboolean rv = FALSE;
 291                 gchar *path = NULL;
 292                 GHashTable *properties = NULL;
 293
 294                 properties = g_hash_table_new(g_str_hash, g_str_equal);
 295                 rv = _ps_context_get_properties(value, properties);
 296                 if (rv != TRUE) {
 297                         g_set_error(&error, PS_ERROR, PS_ERR_INTERNAL, "fail to get properties context(%p)",
 298                                         value);
 299                         dbus_g_method_return_error(context, error);
 300                         g_hash_table_destroy(properties);
 301                         g_hash_table_destroy(contexts);
 302                         return FALSE;
 303                 }
 304
 305                 path = _ps_context_ref_path(value);
 306                 g_hash_table_insert(contexts, g_strdup(path), properties);
 307                 dbg("service (%p) inserted into hash", value);
 308         }
 309
 310         dbus_g_method_return(context, contexts);
 311         g_hash_table_destroy(contexts);
 312
 313         return TRUE;
 314 }
 315
 316 static void __ps_service_emit_property_changed_signal(PsService *service)
 317 {
 318         GHashTable *properties = NULL;
 319
 320         properties = g_hash_table_new(g_str_hash, g_str_equal);
 321         _ps_service_get_properties(service, properties);
 322         g_signal_emit(service, signals[SIG_SERVICE_PROPERTY_CHANGED], 0, properties);
 323         dbg("service (%p) emit property changed signal", service);
 324         g_hash_table_destroy(properties);
 325
 326         return;
 327 }
 328
 329 static void __ps_service_emit_context_added_signal(PsService *service, gpointer context)
 330 {
 331         GHashTable *properties = NULL;
 332
 333         properties = g_hash_table_new(g_str_hash, g_str_equal);
 334         _ps_context_get_properties(context, properties);
 335         g_signal_emit(service, signals[SIG_SERVICE_CONTEXT_ADDED], 0, properties);
 336         dbg("service (%p) emit the context(%p) added signal", service, context);
 337         g_hash_table_destroy(properties);
 338         return;
 339 }
 340
 341 static void __ps_service_emit_context_removed_signal(PsService *service, gpointer context)
 342 {
 343         g_signal_emit(service, signals[SIG_SERVICE_CONTEXT_REMOVED], 0, _ps_context_ref_path(context));
 344         dbg("service (%p) emit the context(%p) removed signal", service, context);
 345         return;
 346 }
 347
 348 static void __remove_context(gpointer data)
 349 {
 350         return;
 351 }
 352
 353 static char *__ps_service_act2string(enum telephony_network_access_technology act)
 354 {
 355         switch (act) {
 356                 case NETWORK_ACT_GSM:
 357                 case NETWORK_ACT_GPRS:
 358                 case NETWORK_ACT_EGPRS:
 359                 case NETWORK_ACT_UMTS:
 360                 case NETWORK_ACT_GSM_UTRAN:
 361                         return "GSM";
 362                 case NETWORK_ACT_IS95A:
 363                 case NETWORK_ACT_IS95B:
 364                 case NETWORK_ACT_CDMA_1X:
 365                 case NETWORK_ACT_EVDO_REV0:
 366                 case NETWORK_ACT_CDMA_1X_EVDO_REV0:
 367                 case NETWORK_ACT_EVDO_REVA:
 368                 case NETWORK_ACT_CDMA_1X_EVDO_REVA:
 369                 case NETWORK_ACT_EVDV:
 370                         return "CDMA";
 371                 case NETWORK_ACT_LTE:
 372                         return "LTE";
 373                 case NETWORK_ACT_UNKNOWN:
 374                 default:
 375                         return "unknown";
 376         }
 377
 378         return NULL;
 379 }
 380
 381 static gboolean __ps_service_check_connection_option(gpointer object)
 382 {
 383         gboolean b_connect = TRUE;
 384         PsService *service = object;
 385
 386         if(service->roaming){
 387                 b_connect &=_ps_modem_get_data_roaming_allowed(service->p_modem);
 388         }
 389
 390         b_connect &= _ps_modem_get_power(service->p_modem);
 391         b_connect &= _ps_modem_get_sim_init(service->p_modem);
 392         b_connect &= _ps_modem_get_data_allowed(service->p_modem);
 393         b_connect &= !_ps_modem_get_flght_mode(service->p_modem);
 394         b_connect &= service->ps_attached;
 395
 396         return b_connect;
 397 }
 398
 399 static gboolean __ps_service_connetion_timeout_handler(gpointer context)
 400 {
 401         int rv = 0;
 402         PsService *service = NULL;
 403
 404         service = _ps_context_ref_service(context);
 405         rv = _ps_service_activate_context(service, context);
 406         dbg("return rv(%d)", rv);
 407
 408         return FALSE;
 409 }
 410
 411 gpointer _ps_service_create_service(DBusGConnection *conn, TcorePlugin *p, gpointer p_modem,
 412                 CoreObject *co_network, CoreObject *co_ps, gchar* path)
 413 {
 414         guint rv = 0;
 415         GObject *object;
 416         DBusGProxy *proxy;
 417         GError *error = NULL;
 418
 419         dbg("service object create");
 420         g_return_val_if_fail(conn != NULL, NULL);
 421         g_return_val_if_fail(p_modem != NULL, NULL);
 422
 423         proxy = dbus_g_proxy_new_for_name(conn, "org.freedesktop.DBus", "/org/freedesktop/DBus",
 424                         "org.freedesktop.DBus");
 425
 426         if (!dbus_g_proxy_call(proxy, "RequestName", &error, G_TYPE_STRING, PS_DBUS_SERVICE,
 427                         G_TYPE_UINT, 0, G_TYPE_INVALID, G_TYPE_UINT, &rv, G_TYPE_INVALID)) {
 428                 err("Failed to acquire context(%s) error(%s)", PS_DBUS_SERVICE, error->message);
 429                 return NULL;
 430         }
 431
 432         object = g_object_new(PS_TYPE_SERVICE, "conn", conn, "plg", p, "p_modem", p_modem, "co_network",
 433                         co_network, "co_ps", co_ps, "path", path, NULL);
 434
 435         _ps_hook_co_network_event(object);
 436         _ps_get_co_network_values(object);
 437         _ps_hook_co_ps_event(object);
 438
 439         dbus_g_connection_register_g_object(conn, path, object);
 440         msg("service(%p) register dbus path(%s)", object, path);
 441
 442         return object;
 443 }
 444
 445 gboolean _ps_service_ref_context(gpointer object, gpointer context)
 446 {
 447         gpointer tmp = NULL;
 448         gchar *s_path = NULL;
 449         PsService *service = object;
 450
 451         dbg("service refer to context");
 452         g_return_val_if_fail(service != NULL, FALSE);
 453
 454         s_path = _ps_context_ref_path(context);
 455         tmp = g_hash_table_lookup(service->contexts, s_path);
 456         if (tmp != NULL) {
 457                 dbg("context(%p) already existed", tmp);
 458                 return FALSE;
 459         }
 460
 461         _ps_context_set_service(context, service);
 462         tcore_ps_add_context(service->co_ps, (CoreObject *) _ps_context_ref_co_context(context));
 463         g_hash_table_insert(service->contexts, g_strdup(s_path), context);
 464
 465         dbg("context(%p) insert to hash", context);
 466         __ps_service_emit_context_added_signal(service, context);
 467
 468         //_ps_service_connect_default_context(service);
 469         return TRUE;
 470 }
 471
 472 gboolean _ps_service_ref_contexts(gpointer object, GHashTable *contexts, gchar *operator)
 473 {
 474         GHashTableIter iter;
 475         gpointer key, value;
 476         PsService *service = object;
 477
 478         dbg("service refer to contexts");
 479         g_return_val_if_fail(service != NULL, FALSE);
 480
 481         g_hash_table_iter_init(&iter, contexts);
 482         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 483                 gchar *s_path = NULL;
 484                 gpointer tmp = NULL;
 485
 486                 s_path = _ps_context_ref_path(value);
 487                 tmp = g_hash_table_lookup(service->contexts, s_path);
 488                 if (tmp != NULL) {
 489                         dbg("context(%p) already existed", tmp);
 490                         continue;
 491                 }
 492
 493                 _ps_context_set_service(value, service);
 494                 tcore_ps_add_context(service->co_ps, (CoreObject *) _ps_context_ref_co_context(value));
 495                 g_hash_table_insert(service->contexts, g_strdup(s_path), value);
 496
 497                 dbg("context(%p) insert to hash", value);
 498                 __ps_service_emit_context_added_signal(service, value);
 499         }
 500
 501         _ps_update_cellular_state_key(service);
 502         _ps_service_connect_default_context(service);
 503         return TRUE;
 504 }
 505
 506 gboolean _ps_service_unref_context(gpointer object, gpointer context)
 507 {
 508         PsService *service = object;
 509
 510         dbg("service unref contexts");
 511         g_return_val_if_fail(service != NULL, FALSE);
 512         g_return_val_if_fail(context != NULL, FALSE);
 513
 514         dbg("remove context(%p) from service(%p)", context, service);
 515         tcore_ps_remove_context(service->co_ps, (CoreObject *) _ps_context_ref_co_context(context));
 516         g_hash_table_remove(service->contexts, _ps_context_ref_path(context));
 517         __ps_service_emit_context_removed_signal(service, context);
 518
 519         return TRUE;
 520 }
 521
 522 gboolean _ps_service_get_properties(gpointer object, GHashTable *properties)
 523 {
 524         PsService *service = object;
 525
 526         dbg("get service properties");
 527         g_return_val_if_fail(service != NULL, FALSE);
 528         g_return_val_if_fail(properties != NULL, FALSE);
 529
 530         g_hash_table_insert(properties, "path", g_strdup(service->path));
 531         g_hash_table_insert(properties, "ps_attached", BOOL2STRING(service->ps_attached));
 532         g_hash_table_insert(properties, "roaming", BOOL2STRING(service->roaming));
 533         g_hash_table_insert(properties, "act", __ps_service_act2string(service->act));
 534
 535         return TRUE;
 536 }
 537
 538 gchar* _ps_service_ref_path(gpointer object)
 539 {
 540         PsService *service = object;
 541         g_return_val_if_fail(service != NULL, NULL);
 542
 543         return service->path;
 544 }
 545
 546 gpointer _ps_service_ref_plugin(gpointer object)
 547 {
 548         PsService *service = object;
 549         g_return_val_if_fail(service != NULL, NULL);
 550
 551         return service->plg;
 552 }
 553
 554 gpointer _ps_service_ref_co_network(gpointer object)
 555 {
 556         PsService *service = object;
 557         g_return_val_if_fail(service != NULL, NULL);
 558
 559         return service->co_network;
 560 }
 561
 562 gpointer _ps_service_ref_co_ps(gpointer object)
 563 {
 564         PsService *service = object;
 565         g_return_val_if_fail(service != NULL, NULL);
 566
 567         return service->co_ps;
 568 }
 569
 570 gboolean _ps_service_set_context_info(gpointer object, struct tnoti_ps_pdp_ipconfiguration *devinfo)
 571 {
 572         GSList* contexts = NULL;
 573         PsService *service = object;
 574
 575         dbg("set context info");
 576         g_return_val_if_fail(service != NULL, FALSE);
 577
 578         contexts = tcore_ps_ref_context_by_id(service->co_ps, devinfo->context_id);
 579         do {
 580                 CoreObject *co_context = NULL;
 581
 582                 co_context = contexts->data;
 583                 if (!co_context) continue;
 584
 585                 tcore_context_set_devinfo(co_context, devinfo);
 586
 587         } while ((contexts = g_slist_next(contexts)));
 588
 589         return TRUE;
 590 }
 591
 592 int _ps_service_activate_context(gpointer object, gpointer context)
 593 {
 594         PsService *service = object;
 595         CoreObject *co_context = NULL;
 596         gboolean b_connect = TRUE;
 597
 598         dbg("activate context");
 599         g_return_val_if_fail(service != NULL, FALSE);
 600
 601         co_context = (CoreObject *)_ps_context_ref_co_context(context);
 602
 603         b_connect = __ps_service_check_connection_option(service);
 604         if(!b_connect)
 605                 return TCORE_RETURN_EPERM;
 606
 607         return tcore_ps_activate_context(service->co_ps, co_context, NULL);
 608 }
 609
 610 gboolean _ps_service_deactivate_context(gpointer object, gpointer context)
 611 {
 612         PsService *service = object;
 613         CoreObject *co_context = NULL;
 614
 615         dbg("deactivate context");
 616         g_return_val_if_fail(service != NULL, FALSE);
 617
 618         co_context = (CoreObject *)_ps_context_ref_co_context(context);
 619
 620         return tcore_ps_deactivate_context(service->co_ps, co_context, NULL);
 621 }
 622
 623 void _ps_service_connection_timer(gpointer object, gpointer context)
 624 {
 625         gboolean f_awo = FALSE;
 626
 627         f_awo = _ps_context_get_alwayson_enable(context);
 628         if(!f_awo)
 629                 return;
 630
 631         timer_src = g_timeout_add_seconds(connection_timeout, __ps_service_connetion_timeout_handler, context);
 632
 633         dbg("cellular service timer started timer src(%d), timeout(%d)", timer_src, connection_timeout);
 634         connection_timeout = connection_timeout*2;
 635         if(connection_timeout > TIMEOUT_MAX)
 636                 connection_timeout = TIMEOUT_MAX;
 637
 638         return;
 639 }
 640
 641 void _ps_service_reset_connection_timer(gpointer context)
 642 {
 643         gboolean f_awo = FALSE;
 644
 645         f_awo = _ps_context_get_alwayson_enable(context);
 646         if(!f_awo)
 647                 return;
 648
 649         connection_timeout = TIMEOUT_DEFAULT;
 650
 651         if (timer_src != 0) {
 652                 dbg("remove connection retry timer (%d)", timer_src);
 653                 g_source_remove(timer_src);
 654                 timer_src = 0;
 655         }
 656
 657         return;
 658 }
 659
 660 void _ps_service_reset_contexts(gpointer object)
 661 {
 662         GHashTableIter iter;
 663         gpointer key, value;
 664         PsService *service = object;
 665
 666         dbg("service disconnect all contexts");
 667         g_return_if_fail(service != NULL);
 668
 669         g_hash_table_iter_init(&iter, service->contexts);
 670         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 671                 int state;
 672                 CoreObject *context = NULL;
 673
 674                 _ps_service_reset_connection_timer(value);
 675
 676                 context = _ps_context_ref_co_context(value);
 677                 state = tcore_context_get_state(context);
 678                 if(state == CONTEXT_STATE_DEACTIVATED){
 679                         continue;
 680                 }
 681
 682                 tcore_ps_clear_context_id(service->co_ps, context);
 683                 _ps_context_set_connected(value, FALSE);
 684         }
 685
 686         return;
 687 }
 688
 689 void _ps_service_disconnect_contexts(gpointer object)
 690 {
 691         GHashTableIter iter;
 692         gpointer key, value;
 693         PsService *service = object;
 694
 695         dbg("service disconnect all contexts");
 696         g_return_if_fail(service != NULL);
 697
 698         g_hash_table_iter_init(&iter, service->contexts);
 699         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 700                 _ps_service_reset_connection_timer(value);
 701                 _ps_service_deactivate_context(service, value);
 702         }
 703
 704         return;
 705 }
 706
 707 void _ps_service_connect_default_context(gpointer object)
 708 {
 709         GHashTableIter iter;
 710         gpointer key, value;
 711         PsService *service = object;
 712
 713         dbg("service connect default context");
 714         g_return_if_fail(service != NULL);
 715
 716         g_hash_table_iter_init(&iter, service->contexts);
 717         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 718                 gboolean f_awo = FALSE;
 719                 f_awo = _ps_context_get_alwayson_enable(value);
 720
 721                 if(f_awo && (service->act > NETWORK_ACT_UNKNOWN && service->act < NETWORK_ACT_LTE)){
 722                         int rv = 0;
 723                         _ps_service_reset_connection_timer(value);
 724                         rv = _ps_service_activate_context(service, value);
 725                         dbg("return rv(%d)", rv);
 726                         break;
 727                 }
 728         }
 729
 730         return;
 731 }
 732
 733 gboolean _ps_service_processing_network_event(gpointer object, gboolean ps_attached, gboolean roaming)
 734 {
 735         PsService *service = object;
 736         g_return_val_if_fail(service != NULL, FALSE);
 737
 738         _ps_update_cellular_state_key(service);
 739         if(service->ps_attached == ps_attached && service->roaming == roaming)
 740                 return TRUE;
 741
 742         _ps_service_set_ps_attached(service, ps_attached);
 743         _ps_service_set_roaming(service, roaming);
 744
 745         if(service->ps_attached)
 746                 _ps_service_connect_default_context(service);
 747         return TRUE;
 748 }
 749
 750 gboolean _ps_service_set_connected(gpointer object, int context_id, gboolean enabled)
 751 {
 752         GHashTableIter iter;
 753         gpointer key, value;
 754         PsService *service = NULL;
 755
 756         service = (PsService *) object;
 757         g_hash_table_iter_init(&iter, service->contexts);
 758         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 759                 CoreObject *context = NULL;
 760                 int tmp_cid;
 761
 762                 context = _ps_context_ref_co_context(value);
 763                 tmp_cid = tcore_context_get_id(context);
 764
 765                 if (tmp_cid != context_id) continue;
 766
 767                 if(!enabled)
 768                         tcore_ps_clear_context_id(service->co_ps, context);
 769
 770                 _ps_context_set_connected(value, enabled);
 771         }
 772
 773         return TRUE;
 774 }
 775
 776 gboolean _ps_service_set_ps_attached(gpointer object, gboolean value)
 777 {
 778         PsService *service = object;
 779         g_return_val_if_fail(service != NULL, FALSE);
 780
 781         service->ps_attached = value;
 782         dbg("service(%p) ps_attached(%d)", service, service->ps_attached);
 783
 784         return TRUE;
 785 }
 786
 787 gboolean _ps_service_get_roaming(gpointer object)
 788 {
 789         PsService *service = object;
 790         g_return_val_if_fail(service != NULL, FALSE);
 791
 792         return service->roaming;
 793 }
 794
 795 gboolean _ps_service_set_roaming(gpointer object, gboolean value)
 796 {
 797         PsService *service = object;
 798         g_return_val_if_fail(service != NULL, FALSE);
 799
 800         service->roaming = value;
 801         dbg("service(%p) roaming(%d)", service, service->roaming);
 802         __ps_service_emit_property_changed_signal(service);
 803
 804         return TRUE;
 805 }
 806
 807 gboolean _ps_service_set_access_technology(gpointer object,
 808                 enum telephony_network_access_technology value)
 809 {
 810         PsService *service = object;
 811         g_return_val_if_fail(service != NULL, FALSE);
 812
 813         service->act = value;
 814         dbg("service(%p) Access Technology(%d)", service, service->act);
 815
 816         if(service->act > NETWORK_ACT_UNKNOWN && service->act < NETWORK_ACT_LTE){
 817                 _ps_update_cellular_state_key(service);
 818                 _ps_service_connect_default_context(service);
 819         }
 820
 821         return TRUE;
 822 }
 823
 824 enum telephony_ps_state _ps_service_check_cellular_state(gpointer object)
 825 {
 826         gboolean state = FALSE;
 827         PsService *service = object;
 828         g_return_val_if_fail(service != NULL, TELEPHONY_PS_NO_SERVICE);
 829
 830         state = _ps_modem_get_power(service->p_modem);
 831         if(!state){
 832                 return TELEPHONY_PS_NO_SERVICE;
 833         }
 834
 835         state = _ps_modem_get_sim_init(service->p_modem);
 836         if(!state){
 837                 return TELEPHONY_PS_NO_SERVICE;
 838         }
 839
 840         if(!service->ps_attached){
 841                 return TELEPHONY_PS_NO_SERVICE;
 842         }
 843
 844         state = _ps_modem_get_flght_mode(service->p_modem);
 845         if(state){
 846                 return TELEPHONY_PS_FLIGHT_MODE;
 847         }
 848
 849         state = _ps_modem_get_data_roaming_allowed(service->p_modem);
 850         if(service->roaming && !state){
 851                 return TELEPHONY_PS_ROAMING_OFF;
 852         }
 853
 854         state = _ps_modem_get_data_allowed(service->p_modem);
 855         if(!state){
 856                 return TELEPHONY_PS_3G_OFF;
 857         }
 858
 859         return TELEPHONY_PS_ON;
 860 }