src/tcore-interface.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.h"
  23
  24 #include <server.h>
  25 #include <plugin.h>
  26 #include <storage.h>
  27 #include <co_ps.h>
  28 #include <co_modem.h>
  29 #include <co_sim.h>
  30 #include <co_network.h>
  31
  32 static enum tcore_hook_return __on_hook_call_status(Server *s, CoreObject *source,
  33                 enum tcore_notification_command command, unsigned int data_len, void *data,
  34                 void *user_data)
  35 {
  36         gpointer service = user_data;
  37         struct tnoti_ps_call_status *cstatus = NULL;
  38
  39         dbg("call status event");
  40         g_return_val_if_fail(service != NULL, TCORE_HOOK_RETURN_STOP_PROPAGATION);
  41
  42         cstatus = (struct tnoti_ps_call_status *) data;
  43         dbg("call status event cid(%d) state(%d)",
  44                         cstatus->context_id, cstatus->state);
  45
  46         //send activation event / deactivation event
  47         if (cstatus->state == PS_DATA_CALL_CTX_DEFINED) {/* OK: PDP define is complete. */
  48                 dbg("service is ready to activate");
  49                 _ps_service_set_ps_defined(service, TRUE, cstatus->context_id);
  50                 //_ps_service_connect_default_context(service);
  51         }
  52         else if (cstatus->state == PS_DATA_CALL_CONNECTED) {/* CONNECTED */
  53                 dbg("service is activated");
  54                 _ps_service_set_connected(service, cstatus->context_id, TRUE);
  55         }
  56         else if (cstatus->state == PS_DATA_CALL_NOT_CONNECTED) { /* NO CARRIER */
  57                 dbg("service is deactivated");
  58                 _ps_service_set_ps_defined(service, FALSE, cstatus->context_id);
  59                 _ps_service_set_connected(service, cstatus->context_id, FALSE);
  60         }
  61
  62         return TCORE_HOOK_RETURN_CONTINUE;
  63 }
  64
  65 static enum tcore_hook_return __on_hook_session_data_counter(Server *s, CoreObject *source,
  66                 enum tcore_notification_command command, unsigned int data_len, void *data,
  67                 void *user_data)
  68 {
  69         g_return_val_if_fail(user_data != NULL, TCORE_HOOK_RETURN_STOP_PROPAGATION);
  70
  71         dbg("session data counter event");
  72
  73         return TCORE_HOOK_RETURN_CONTINUE;
  74 }
  75
  76 static enum tcore_hook_return __on_hook_ipconfiguration(Server *s, CoreObject *source,
  77                 enum tcore_notification_command command, unsigned int data_len, void *data,
  78                 void *user_data)
  79 {
  80         gpointer service = user_data;
  81         CoreObject *co_ps = NULL;
  82         struct tnoti_ps_pdp_ipconfiguration *devinfo = NULL;
  83
  84         g_return_val_if_fail(service != NULL, TCORE_HOOK_RETURN_STOP_PROPAGATION);
  85
  86         devinfo = (struct tnoti_ps_pdp_ipconfiguration *) data;
  87         co_ps = (CoreObject *) _ps_service_ref_co_ps(service);
  88
  89         if (co_ps != source) {
  90                 dbg("ps object is different");
  91                 return TCORE_HOOK_RETURN_CONTINUE;
  92         }
  93
  94         dbg("ip configuration event");
  95         _ps_service_set_context_info(service, devinfo);
  96
  97         return TCORE_HOOK_RETURN_CONTINUE;
  98 }
  99
 100 static enum tcore_hook_return __on_hook_powered(Server *s, CoreObject *source,
 101                 enum tcore_notification_command command, unsigned int data_len, void *data, void *user_data)
 102 {
 103         gpointer modem = user_data;
 104         struct tnoti_modem_power *modem_power = NULL;
 105
 106         gboolean power = FALSE;
 107
 108         dbg("powered event called");
 109
 110         g_return_val_if_fail(modem != NULL, TCORE_HOOK_RETURN_STOP_PROPAGATION);
 111
 112         modem_power = (struct tnoti_modem_power *)data;
 113
 114         if ( modem_power->state == MODEM_STATE_ONLINE )
 115                 power = TRUE;
 116         else
 117                 power = FALSE;
 118
 119         _ps_modem_processing_power_enable(modem, power);
 120
 121         return TCORE_HOOK_RETURN_CONTINUE;
 122 }
 123
 124 static enum tcore_hook_return __on_hook_flight(Server *s, CoreObject *source,
 125                 enum tcore_notification_command command, unsigned int data_len, void *data, void *user_data)
 126 {
 127         gpointer modem = user_data;
 128         struct tnoti_modem_flight_mode *modem_flight = NULL;
 129         dbg("flight event called");
 130
 131         g_return_val_if_fail(modem != NULL, TCORE_HOOK_RETURN_STOP_PROPAGATION);
 132
 133         modem_flight = (struct tnoti_modem_flight_mode *)data;
 134         _ps_modem_processing_flight_mode(modem, modem_flight->enable);
 135
 136         return TCORE_HOOK_RETURN_CONTINUE;
 137 }
 138
 139 static enum tcore_hook_return __on_hook_net_register(Server *s, CoreObject *source,
 140                 enum tcore_notification_command command, unsigned int data_len, void *data,
 141                 void *user_data)
 142 {
 143         gpointer service = user_data;
 144         gboolean ps_attached = FALSE;
 145         struct tnoti_network_registration_status *regist_status;
 146
 147         dbg("network register event called");
 148         g_return_val_if_fail(service != NULL, TCORE_HOOK_RETURN_STOP_PROPAGATION);
 149
 150         regist_status = (struct tnoti_network_registration_status *) data;
 151         if (regist_status->ps_domain_status == NETWORK_SERVICE_DOMAIN_STATUS_FULL)
 152                 ps_attached = TRUE;
 153
 154         _ps_service_processing_network_event(service, ps_attached, regist_status->roaming_status);
 155
 156         return TCORE_HOOK_RETURN_CONTINUE;
 157 }
 158
 159 static enum tcore_hook_return __on_hook_net_change(Server *s, CoreObject *source,
 160                 enum tcore_notification_command command, unsigned int data_len, void *data,
 161                 void *user_data)
 162 {
 163         gpointer service = user_data;
 164         struct tnoti_network_change *network_change;
 165
 166         dbg("network change event called");
 167         g_return_val_if_fail(service != NULL, TCORE_HOOK_RETURN_STOP_PROPAGATION);
 168
 169         network_change = (struct tnoti_network_change *) data;
 170         dbg("plmn(%s) act(%d)", network_change->plmn, network_change->act);
 171         _ps_service_set_access_technology(service, network_change->act);
 172
 173         return TCORE_HOOK_RETURN_CONTINUE;
 174 }
 175
 176 static enum tcore_hook_return __on_hook_sim_init(Server *s, CoreObject *source,
 177                 enum tcore_notification_command command, unsigned int data_len, void *data, void *user_data)
 178 {
 179         struct tnoti_sim_status *sim_data;
 180
 181         dbg("sim init event called");
 182         g_return_val_if_fail(user_data != NULL, TCORE_HOOK_RETURN_STOP_PROPAGATION);
 183
 184         sim_data = (struct tnoti_sim_status *)data;
 185         dbg("sim status is (%d)", sim_data->sim_status);
 186
 187         if( sim_data->sim_status == SIM_STATUS_INIT_COMPLETED){
 188                 struct tel_sim_imsi *sim_imsi = NULL;
 189                 sim_imsi = tcore_sim_get_imsi(source);
 190                 _ps_modem_processing_sim_complete( (gpointer)user_data, TRUE, (gchar *)sim_imsi->plmn);
 191                 g_free(sim_imsi);
 192         }
 193
 194         return TCORE_HOOK_RETURN_CONTINUE;
 195 }
 196
 197 gboolean _ps_hook_co_modem_event(gpointer modem)
 198 {
 199         Server *s = NULL;
 200         TcorePlugin *p;
 201         g_return_val_if_fail(modem != NULL, FALSE);
 202
 203         p = _ps_modem_ref_plugin(modem);
 204         s = tcore_plugin_ref_server(p);
 205
 206         tcore_server_add_notification_hook(s, TNOTI_MODEM_POWER, __on_hook_powered, modem);
 207         tcore_server_add_notification_hook(s, TNOTI_MODEM_FLIGHT_MODE, __on_hook_flight, modem);
 208         tcore_server_add_notification_hook(s, TNOTI_SIM_STATUS, __on_hook_sim_init, modem);
 209
 210         return TRUE;
 211 }
 212
 213 gboolean _ps_get_co_modem_values(gpointer modem)
 214 {
 215         TcorePlugin *plg;
 216         CoreObject *co_modem = NULL;
 217         CoreObject *co_sim = NULL;
 218
 219         gboolean sim_init = FALSE, modem_powered = FALSE, flight_mode = FALSE;
 220         int sim_status = 0;
 221         struct tel_sim_imsi *sim_imsi = NULL;
 222
 223         g_return_val_if_fail(modem != NULL, FALSE);
 224
 225         co_modem = _ps_modem_ref_co_modem(modem);
 226         if (!co_modem)
 227                 return FALSE;
 228
 229         plg = tcore_object_ref_plugin(co_modem);
 230         if (!plg)
 231                 return FALSE;
 232
 233         co_sim = tcore_plugin_ref_core_object(plg, CORE_OBJECT_TYPE_SIM);
 234         if (!co_sim)
 235                 return FALSE;
 236
 237         sim_status = tcore_sim_get_status(co_sim);
 238         if(sim_status == SIM_STATUS_INIT_COMPLETED)
 239                 sim_init = TRUE;
 240
 241         sim_imsi = tcore_sim_get_imsi(co_sim);
 242         modem_powered = tcore_modem_get_powered(co_modem);
 243         flight_mode = tcore_modem_get_flight_mode_state(co_modem);
 244
 245         _ps_modem_processing_flight_mode(modem, flight_mode);
 246         _ps_modem_processing_power_enable(modem, modem_powered);
 247         _ps_modem_processing_sim_complete(modem, sim_init, (gchar *)sim_imsi->plmn);
 248
 249         g_free(sim_imsi);
 250         return TRUE;
 251 }
 252
 253 gboolean _ps_hook_co_network_event(gpointer service)
 254 {
 255         Server *s = NULL;
 256         TcorePlugin *p;
 257
 258         g_return_val_if_fail(service != NULL, FALSE);
 259
 260         p = _ps_service_ref_plugin(service);
 261         s = tcore_plugin_ref_server(p);
 262
 263         tcore_server_add_notification_hook(s, TNOTI_NETWORK_REGISTRATION_STATUS, __on_hook_net_register, service);
 264         tcore_server_add_notification_hook(s, TNOTI_NETWORK_CHANGE, __on_hook_net_change, service);
 265
 266         return TRUE;
 267 }
 268
 269 gboolean _ps_get_co_network_values(gpointer service)
 270 {
 271         CoreObject *co_network = NULL;
 272         gboolean ps_attached = FALSE;
 273
 274         enum telephony_network_service_domain_status ps_status;
 275         enum telephony_network_access_technology act;
 276
 277         g_return_val_if_fail(service != NULL, FALSE);
 278
 279         co_network = _ps_service_ref_co_network(service);
 280
 281         tcore_network_get_service_status(co_network, TCORE_NETWORK_SERVICE_DOMAIN_TYPE_PACKET, &ps_status);
 282         tcore_network_get_access_technology(co_network, &act);
 283
 284         if (ps_status == NETWORK_SERVICE_DOMAIN_STATUS_FULL)
 285                 ps_attached = TRUE;
 286
 287         _ps_service_set_roaming(service, tcore_network_get_roaming_state(co_network));
 288         _ps_service_set_ps_attached(service, ps_attached);
 289         _ps_service_set_access_technology(service, act);
 290
 291         return TRUE;
 292 }
 293
 294 gboolean _ps_hook_co_ps_event(gpointer service)
 295 {
 296         Server *s = NULL;
 297         TcorePlugin *p;
 298         g_return_val_if_fail(service != NULL, FALSE);
 299
 300         p = _ps_service_ref_plugin(service);
 301         s = tcore_plugin_ref_server(p);
 302
 303         tcore_server_add_notification_hook(s, TNOTI_PS_CALL_STATUS, __on_hook_call_status, service);
 304         tcore_server_add_notification_hook(s, TNOTI_PS_CURRENT_SESSION_DATA_COUNTER, __on_hook_session_data_counter, service);
 305         tcore_server_add_notification_hook(s, TNOTI_PS_PDP_IPCONFIGURATION, __on_hook_ipconfiguration, service);
 306
 307         return TRUE;
 308 }
 309
 310 gboolean _ps_free_co_ps_event(gpointer service)
 311 {
 312         Server *s = NULL;
 313         TcorePlugin *p;
 314         g_return_val_if_fail(service != NULL, FALSE);
 315
 316         p = _ps_service_ref_plugin(service);
 317         s = tcore_plugin_ref_server(p);
 318
 319         tcore_server_remove_notification_hook(s, __on_hook_call_status);
 320         tcore_server_remove_notification_hook(s, __on_hook_session_data_counter);
 321         tcore_server_remove_notification_hook(s, __on_hook_ipconfiguration);
 322
 323         return TRUE;
 324 }
 325
 326 gboolean _ps_free_co_network_event(gpointer service)
 327 {
 328         Server *s = NULL;
 329         TcorePlugin *p;
 330         g_return_val_if_fail(service != NULL, FALSE);
 331
 332         p = _ps_service_ref_plugin(service);
 333         s = tcore_plugin_ref_server(p);
 334
 335         tcore_server_remove_notification_hook(s, __on_hook_net_register);
 336         tcore_server_remove_notification_hook(s, __on_hook_net_change);
 337
 338         return TRUE;
 339 }
 340
 341 gboolean _ps_update_cellular_state_key(gpointer service)
 342 {
 343         Server *s = NULL;
 344         gpointer handle = NULL;
 345         static Storage *strg;
 346         int err_reason = 0;
 347
 348         s = tcore_plugin_ref_server( (TcorePlugin *)_ps_service_ref_plugin(service) );
 349         strg = tcore_server_find_storage(s, "vconf");
 350         handle = tcore_storage_create_handle(strg, "vconf");
 351         if (!handle){
 352                 err("fail to create vconf handle");
 353                 return FALSE;
 354         }
 355
 356         err_reason = _ps_service_check_cellular_state(service);
 357         tcore_storage_set_int(strg,STORAGE_KEY_CELLULAR_STATE, err_reason);
 358
 359         return TRUE;
 360 }