src/service.c

   1 /*
   2  * tel-plugin-packetservice
   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 = NULL;
 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 = NULL;
 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         gboolean power, sim, data, flight;
 385         PsService *service = object;
 386
 387         if(service->roaming){
 388                 b_connect &=_ps_modem_get_data_roaming_allowed(service->p_modem);
 389         }
 390
 391         power = _ps_modem_get_power(service->p_modem);
 392         sim = _ps_modem_get_sim_init(service->p_modem);
 393         data = _ps_modem_get_data_allowed(service->p_modem);
 394         flight = _ps_modem_get_flght_mode(service->p_modem);
 395         b_connect &= power;
 396         b_connect &= sim;
 397         b_connect &= data;
 398         b_connect &= !flight;
 399         dbg("power(%d), sim init(%d), data allowed(%d), filght mode(%d)", power, sim, data, flight);
 400
 401         return b_connect;
 402 }
 403
 404 static gboolean __ps_service_connetion_timeout_handler(gpointer context)
 405 {
 406         int rv = 0;
 407         PsService *service = NULL;
 408
 409         service = _ps_context_ref_service(context);
 410         rv = _ps_service_activate_context(service, context);
 411         dbg("return rv(%d)", rv);
 412
 413         return FALSE;
 414 }
 415
 416 gpointer _ps_service_create_service(DBusGConnection *conn, TcorePlugin *p, gpointer p_modem,
 417                 CoreObject *co_network, CoreObject *co_ps, gchar* path)
 418 {
 419         guint rv = 0;
 420         GObject *object;
 421         DBusGProxy *proxy;
 422         GError *error = NULL;
 423
 424         dbg("service object create");
 425         g_return_val_if_fail(conn != NULL, NULL);
 426         g_return_val_if_fail(p_modem != NULL, NULL);
 427
 428         proxy = dbus_g_proxy_new_for_name(conn, "org.freedesktop.DBus", "/org/freedesktop/DBus",
 429                         "org.freedesktop.DBus");
 430
 431         if (!dbus_g_proxy_call(proxy, "RequestName", &error, G_TYPE_STRING, PS_DBUS_SERVICE,
 432                         G_TYPE_UINT, 0, G_TYPE_INVALID, G_TYPE_UINT, &rv, G_TYPE_INVALID)) {
 433                 err("Failed to acquire context(%s) error(%s)", PS_DBUS_SERVICE, error->message);
 434                 return NULL;
 435         }
 436
 437         object = g_object_new(PS_TYPE_SERVICE, "conn", conn, "plg", p, "p_modem", p_modem, "co_network",
 438                         co_network, "co_ps", co_ps, "path", path, NULL);
 439
 440         _ps_hook_co_network_event(object);
 441         _ps_get_co_network_values(object);
 442         _ps_hook_co_ps_event(object);
 443
 444         dbus_g_connection_register_g_object(conn, path, object);
 445         msg("service(%p) register dbus path(%s)", object, path);
 446
 447         return object;
 448 }
 449
 450 gboolean _ps_service_ref_context(gpointer object, gpointer context)
 451 {
 452         gpointer tmp = NULL;
 453         gchar *s_path = NULL;
 454         PsService *service = object;
 455
 456         dbg("service refer to context");
 457         g_return_val_if_fail(service != NULL, FALSE);
 458
 459         s_path = _ps_context_ref_path(context);
 460         tmp = g_hash_table_lookup(service->contexts, s_path);
 461         if (tmp != NULL) {
 462                 dbg("context(%p) already existed", tmp);
 463                 return FALSE;
 464         }
 465
 466         _ps_context_set_service(context, service);
 467         tcore_ps_add_context(service->co_ps, (CoreObject *) _ps_context_ref_co_context(context));
 468         g_hash_table_insert(service->contexts, g_strdup(s_path), context);
 469
 470         dbg("context(%p) insert to hash", context);
 471         __ps_service_emit_context_added_signal(service, context);
 472
 473         //_ps_service_connect_default_context(service);
 474         return TRUE;
 475 }
 476
 477 gboolean _ps_service_ref_contexts(gpointer object, GHashTable *contexts, gchar *operator)
 478 {
 479         GHashTableIter iter;
 480         gpointer key, value;
 481         PsService *service = object;
 482         gboolean ret = TRUE;
 483         int rv;
 484
 485         dbg("service refer to contexts");
 486         g_return_val_if_fail(service != NULL, FALSE);
 487
 488         g_hash_table_iter_init(&iter, contexts);
 489         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 490                 gchar *s_path = NULL;
 491                 gpointer tmp = NULL;
 492                 gboolean f_awo = FALSE;
 493
 494                 s_path = _ps_context_ref_path(value);
 495                 tmp = g_hash_table_lookup(service->contexts, s_path);
 496                 if (tmp != NULL) {
 497                         dbg("context(%p) already existed", tmp);
 498                         continue;
 499                 }
 500
 501                 _ps_context_set_service(value, service);
 502                 tcore_ps_add_context(service->co_ps, (CoreObject *) _ps_context_ref_co_context(value));
 503                 g_hash_table_insert(service->contexts, g_strdup(s_path), value);
 504
 505                 dbg("context(%p) insert to hash", value);
 506                 __ps_service_emit_context_added_signal(service, value);
 507
 508                 f_awo = _ps_context_get_alwayson_enable(value);
 509                 if(f_awo){
 510                         rv = _ps_service_define_context(service, value);
 511                         dbg("return rv(%d)", rv);
 512                 }
 513         }
 514
 515         _ps_update_cellular_state_key(service);
 516         //_ps_service_connect_default_context(service);
 517         return ret;
 518 }
 519
 520 gboolean _ps_service_unref_context(gpointer object, gpointer context)
 521 {
 522         PsService *service = object;
 523
 524         dbg("service unref contexts");
 525         g_return_val_if_fail(service != NULL, FALSE);
 526         g_return_val_if_fail(context != NULL, FALSE);
 527
 528         dbg("remove context(%p) from service(%p)", context, service);
 529         tcore_ps_remove_context(service->co_ps, (CoreObject *) _ps_context_ref_co_context(context));
 530         g_hash_table_remove(service->contexts, _ps_context_ref_path(context));
 531         __ps_service_emit_context_removed_signal(service, context);
 532
 533         return TRUE;
 534 }
 535
 536 gboolean _ps_service_get_properties(gpointer object, GHashTable *properties)
 537 {
 538         PsService *service = object;
 539
 540         dbg("get service properties");
 541         g_return_val_if_fail(service != NULL, FALSE);
 542         g_return_val_if_fail(properties != NULL, FALSE);
 543
 544         g_hash_table_insert(properties, "path", g_strdup(service->path));
 545         g_hash_table_insert(properties, "ps_attached", BOOL2STRING(service->ps_attached));
 546         g_hash_table_insert(properties, "roaming", BOOL2STRING(service->roaming));
 547         g_hash_table_insert(properties, "act", __ps_service_act2string(service->act));
 548
 549         return TRUE;
 550 }
 551
 552 gchar* _ps_service_ref_path(gpointer object)
 553 {
 554         PsService *service = object;
 555         g_return_val_if_fail(service != NULL, NULL);
 556
 557         return service->path;
 558 }
 559
 560 gpointer _ps_service_ref_plugin(gpointer object)
 561 {
 562         PsService *service = object;
 563         g_return_val_if_fail(service != NULL, NULL);
 564
 565         return service->plg;
 566 }
 567
 568 gpointer _ps_service_ref_co_network(gpointer object)
 569 {
 570         PsService *service = object;
 571         g_return_val_if_fail(service != NULL, NULL);
 572
 573         return service->co_network;
 574 }
 575
 576 gpointer _ps_service_ref_co_ps(gpointer object)
 577 {
 578         PsService *service = object;
 579         g_return_val_if_fail(service != NULL, NULL);
 580
 581         return service->co_ps;
 582 }
 583
 584 gboolean _ps_service_set_context_info(gpointer object, struct tnoti_ps_pdp_ipconfiguration *devinfo)
 585 {
 586         GSList* contexts = NULL;
 587         PsService *service = object;
 588
 589         dbg("set context info");
 590         g_return_val_if_fail(service != NULL, FALSE);
 591
 592         contexts = tcore_ps_ref_context_by_id(service->co_ps, devinfo->context_id);
 593
 594         if (NULL == contexts) {
 595                 dbg("fail to ref context by cid.");
 596                 return FALSE;
 597         }
 598
 599         for (; contexts != NULL; contexts = g_slist_next(contexts)) {
 600                 CoreObject *co_context = NULL;
 601
 602                 co_context = contexts->data;
 603                 if (NULL == co_context)
 604                         continue;
 605
 606                 tcore_context_set_devinfo(co_context, devinfo);
 607         }
 608
 609         return TRUE;
 610 }
 611
 612 int _ps_service_define_context(gpointer object, gpointer context)
 613 {
 614         PsService *service = object;
 615         CoreObject *co_context = NULL;
 616         gboolean b_connect = TRUE;
 617
 618         dbg("define context(%p)", context);
 619         g_return_val_if_fail(service != NULL, FALSE);
 620
 621         co_context = (CoreObject *)_ps_context_ref_co_context(context);
 622
 623         b_connect = __ps_service_check_connection_option(service);
 624         if(!b_connect)
 625                 return TCORE_RETURN_EPERM;
 626
 627         return tcore_ps_define_context(service->co_ps, co_context, NULL);
 628 }
 629
 630 int _ps_service_activate_context(gpointer object, gpointer context)
 631 {
 632         PsService *service = object;
 633         CoreObject *co_context = NULL;
 634         gboolean b_connect = TRUE;
 635         gboolean ps_defined;
 636         int ret = TCORE_RETURN_FAILURE;
 637
 638         dbg("activate context(%p)", context);
 639         g_return_val_if_fail(service != NULL, FALSE);
 640
 641         co_context = (CoreObject *)_ps_context_ref_co_context(context);
 642
 643         b_connect = __ps_service_check_connection_option(service);
 644         b_connect &= service->ps_attached;
 645         if(!b_connect)
 646                 return TCORE_RETURN_EPERM;
 647
 648         ps_defined = _ps_context_get_ps_defined(context);
 649         if(!ps_defined) {
 650                 dbg("pdp profile is not defined yet, define first. ");
 651                 ret = tcore_ps_define_context(service->co_ps, co_context, NULL);
 652         }
 653         else {
 654                 dbg("pdp profile is defined, activate context. ");
 655                 ret = tcore_ps_activate_context(service->co_ps, co_context, NULL);
 656         }
 657
 658         return ret;
 659 }
 660
 661 gboolean _ps_service_deactivate_context(gpointer object, gpointer context)
 662 {
 663         PsService *service = object;
 664         CoreObject *co_context = NULL;
 665
 666         dbg("deactivate context(%p)", context);
 667         g_return_val_if_fail(service != NULL, FALSE);
 668
 669         co_context = (CoreObject *)_ps_context_ref_co_context(context);
 670
 671         return tcore_ps_deactivate_context(service->co_ps, co_context, NULL);
 672 }
 673
 674 void _ps_service_connection_timer(gpointer object, gpointer context)
 675 {
 676         gboolean f_awo = FALSE;
 677
 678         f_awo = _ps_context_get_alwayson_enable(context);
 679         if(!f_awo)
 680                 return;
 681
 682         timer_src = g_timeout_add_seconds(connection_timeout, __ps_service_connetion_timeout_handler, context);
 683
 684         dbg("cellular service timer started timer src(%d), timeout(%d)", timer_src, connection_timeout);
 685         connection_timeout = connection_timeout*2;
 686         if(connection_timeout > TIMEOUT_MAX)
 687                 connection_timeout = TIMEOUT_MAX;
 688
 689         return;
 690 }
 691
 692 void _ps_service_reset_connection_timer(gpointer context)
 693 {
 694         gboolean f_awo = FALSE;
 695
 696         f_awo = _ps_context_get_alwayson_enable(context);
 697         if(!f_awo)
 698                 return;
 699
 700         connection_timeout = TIMEOUT_DEFAULT;
 701
 702         if (timer_src != 0) {
 703                 dbg("remove connection retry timer (%d)", timer_src);
 704                 g_source_remove(timer_src);
 705                 timer_src = 0;
 706         }
 707
 708         return;
 709 }
 710
 711 void _ps_service_remove_contexts(gpointer object)
 712 {
 713         GHashTableIter iter;
 714         gpointer key, value;
 715         PsService *service = object;
 716
 717         dbg("service remove all contexts");
 718         g_return_if_fail(service != NULL);
 719
 720         g_hash_table_iter_init(&iter, service->contexts);
 721         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 722                 gpointer co_context = NULL;
 723
 724                 dbg("key(%s), value(%p) context", key, value);
 725                 co_context = _ps_context_ref_co_context(value);
 726
 727                 _ps_service_reset_connection_timer(value);
 728                 _ps_context_set_alwayson_enable(value, FALSE);
 729                 _ps_service_deactivate_context(service, value);
 730                 _ps_context_set_connected(value, FALSE);
 731                 tcore_ps_remove_context(service->co_ps, co_context);
 732                 tcore_context_free(co_context);
 733
 734                 __ps_service_emit_context_removed_signal(service, value);
 735                 _ps_context_remove_context(value);
 736         }
 737
 738         g_hash_table_remove_all(service->contexts);
 739         return;
 740 }
 741
 742 void _ps_service_disconnect_contexts(gpointer object)
 743 {
 744         GHashTableIter iter;
 745         gpointer key, value;
 746         PsService *service = object;
 747
 748         dbg("service disconnect all contexts");
 749         g_return_if_fail(service != NULL);
 750
 751         g_hash_table_iter_init(&iter, service->contexts);
 752         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 753                 _ps_service_reset_connection_timer(value);
 754                 _ps_service_deactivate_context(service, value);
 755         }
 756
 757         return;
 758 }
 759
 760 void _ps_service_connect_default_context(gpointer object)
 761 {
 762         GHashTableIter iter;
 763         gpointer key, value;
 764         PsService *service = object;
 765
 766         dbg("service connect default context");
 767         g_return_if_fail(service != NULL);
 768
 769         g_hash_table_iter_init(&iter, service->contexts);
 770         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 771                 gboolean f_awo = FALSE;
 772                 f_awo = _ps_context_get_alwayson_enable(value);
 773
 774                 if(f_awo){
 775                         int rv = 0;
 776                         _ps_service_reset_connection_timer(value);
 777                         rv = _ps_service_activate_context(service, value);
 778                         dbg("return rv(%d)", rv);
 779                         break;
 780                 }
 781         }
 782
 783         return;
 784 }
 785
 786 gpointer _ps_service_return_default_context(gpointer object)
 787 {
 788         GHashTableIter iter;
 789         gpointer key, value;
 790         PsService *service = object;
 791
 792         g_return_val_if_fail(service != NULL, NULL);
 793
 794         g_hash_table_iter_init(&iter, service->contexts);
 795         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 796                 gboolean b_default = FALSE;
 797                 b_default = _ps_context_get_default_internet(value);
 798
 799                 if(b_default){
 800                         return value;
 801                 }
 802         }
 803
 804         return NULL;
 805 }
 806
 807 gboolean _ps_service_processing_network_event(gpointer object, gboolean ps_attached, gboolean roaming)
 808 {
 809         PsService *service = object;
 810         g_return_val_if_fail(service != NULL, FALSE);
 811
 812         _ps_update_cellular_state_key(service);
 813         if(service->ps_attached == ps_attached && service->roaming == roaming)
 814                 return TRUE;
 815
 816         _ps_service_set_ps_attached(service, ps_attached);
 817         _ps_service_set_roaming(service, roaming);
 818
 819         if(service->ps_attached)
 820                 _ps_service_connect_default_context(service);
 821
 822         return TRUE;
 823 }
 824
 825 gboolean _ps_service_set_connected(gpointer object, int context_id, gboolean enabled)
 826 {
 827         GHashTableIter iter;
 828         gpointer key, value;
 829         PsService *service = NULL;
 830
 831         service = (PsService *) object;
 832         g_hash_table_iter_init(&iter, service->contexts);
 833         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 834                 CoreObject *context = NULL;
 835                 int tmp_cid;
 836
 837                 context = _ps_context_ref_co_context(value);
 838                 tmp_cid = tcore_context_get_id(context);
 839
 840                 if (tmp_cid != context_id) continue;
 841
 842                 if(!enabled)
 843                         tcore_ps_clear_context_id(service->co_ps, context);
 844
 845                 _ps_context_set_connected(value, enabled);
 846         }
 847
 848         return TRUE;
 849 }
 850
 851 void _ps_service_set_ps_defined(gpointer *object, gboolean value, int cid)
 852 {
 853         PsService *service = (PsService*)object;
 854         GHashTableIter iter;
 855         gpointer key, out;
 856
 857         g_return_if_fail(service != NULL);
 858
 859         g_hash_table_iter_init(&iter, service->contexts);
 860         while (g_hash_table_iter_next(&iter, &key, &out) == TRUE) {
 861                 gboolean r_actvate = 0;
 862                 r_actvate = _ps_context_set_ps_defined(out, value, cid);
 863                 r_actvate &= value;
 864                 if(r_actvate) {
 865                         int rv;
 866                         dbg("define is complete, activate context for cid(%d)", cid);
 867                         rv = _ps_service_activate_context(service, out);
 868                         dbg("rv(%d)",rv);
 869                         break;
 870                 }
 871         }
 872
 873         return;
 874 }
 875
 876 gboolean _ps_service_set_ps_attached(gpointer object, gboolean value)
 877 {
 878         PsService *service = object;
 879         g_return_val_if_fail(service != NULL, FALSE);
 880
 881         service->ps_attached = value;
 882         dbg("service(%p) ps_attached(%d)", service, service->ps_attached);
 883
 884         return TRUE;
 885 }
 886
 887 gboolean _ps_service_get_roaming(gpointer object)
 888 {
 889         PsService *service = object;
 890         g_return_val_if_fail(service != NULL, FALSE);
 891
 892         return service->roaming;
 893 }
 894
 895 gboolean _ps_service_set_roaming(gpointer object, gboolean value)
 896 {
 897         PsService *service = object;
 898         g_return_val_if_fail(service != NULL, FALSE);
 899
 900         service->roaming = value;
 901         dbg("service(%p) roaming(%d)", service, service->roaming);
 902         __ps_service_emit_property_changed_signal(service);
 903
 904         return TRUE;
 905 }
 906
 907 gboolean _ps_service_set_access_technology(gpointer object,
 908                 enum telephony_network_access_technology value)
 909 {
 910         PsService *service = object;
 911         g_return_val_if_fail(service != NULL, FALSE);
 912
 913         service->act = value;
 914         dbg("service(%p) Access Technology(%d)", service, service->act);
 915
 916         if(service->act > NETWORK_ACT_UNKNOWN && service->act < NETWORK_ACT_NOT_SPECIFIED){
 917                 _ps_update_cellular_state_key(service);
 918                 _ps_service_connect_default_context(service);
 919         }
 920
 921         return TRUE;
 922 }
 923
 924 enum telephony_ps_state _ps_service_check_cellular_state(gpointer object)
 925 {
 926         gboolean state = FALSE;
 927         PsService *service = object;
 928         g_return_val_if_fail(service != NULL, TELEPHONY_PS_NO_SERVICE);
 929
 930         state = _ps_modem_get_power(service->p_modem);
 931         if(!state){
 932                 return TELEPHONY_PS_NO_SERVICE;
 933         }
 934
 935         state = _ps_modem_get_sim_init(service->p_modem);
 936         if(!state){
 937                 return TELEPHONY_PS_NO_SERVICE;
 938         }
 939
 940         if(!service->ps_attached){
 941                 return TELEPHONY_PS_NO_SERVICE;
 942         }
 943
 944         state = _ps_modem_get_flght_mode(service->p_modem);
 945         if(state){
 946                 return TELEPHONY_PS_FLIGHT_MODE;
 947         }
 948
 949         state = _ps_modem_get_data_roaming_allowed(service->p_modem);
 950         if(service->roaming && !state){
 951                 return TELEPHONY_PS_ROAMING_OFF;
 952         }
 953
 954         state = _ps_modem_get_data_allowed(service->p_modem);
 955         if(!state){
 956                 return TELEPHONY_PS_3G_OFF;
 957         }
 958
 959         return TELEPHONY_PS_ON;
 960 }