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) reason(%d)",
  44                         cstatus->context_id, cstatus->state, cstatus->result);
  45
  46         //send activation event / deactivation event
  47         if (cstatus->state == 0) {/* 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 == 1) {/* CONNECTED */
  53                 dbg("service is activated");
  54                 _ps_service_set_connected(service, cstatus->context_id, TRUE);
  55         }
  56         else if (cstatus->state == 3) { /* 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         GSList *co_lists = NULL;
 220         gboolean sim_init = FALSE, modem_powered = FALSE, flight_mode = FALSE;
 221         int sim_status = 0;
 222         struct tel_sim_imsi *sim_imsi = NULL;
 223
 224         g_return_val_if_fail(modem != NULL, FALSE);
 225
 226         co_modem = _ps_modem_ref_co_modem(modem);
 227         if (!co_modem)
 228                 return FALSE;
 229
 230         plg = tcore_object_ref_plugin(co_modem);
 231         if (!plg)
 232                 return FALSE;
 233
 234         co_lists = tcore_plugin_get_core_objects_bytype(plg, CORE_OBJECT_TYPE_SIM);
 235         if (!co_lists)
 236                 return FALSE;
 237
 238         co_sim = co_lists->data;
 239         g_slist_free(co_lists);
 240
 241         sim_status = tcore_sim_get_status(co_sim);
 242         if(sim_status == SIM_STATUS_INIT_COMPLETED)
 243                 sim_init = TRUE;
 244
 245         sim_imsi = tcore_sim_get_imsi(co_sim);
 246         modem_powered = tcore_modem_get_powered(co_modem);
 247         flight_mode = tcore_modem_get_flight_mode_state(co_modem);
 248
 249         _ps_modem_processing_flight_mode(modem, flight_mode);
 250         _ps_modem_processing_power_enable(modem, modem_powered);
 251         _ps_modem_processing_sim_complete(modem, sim_init, (gchar *)sim_imsi->plmn);
 252
 253         g_free(sim_imsi);
 254         return TRUE;
 255 }
 256
 257 gboolean _ps_hook_co_network_event(gpointer service)
 258 {
 259         Server *s = NULL;
 260         TcorePlugin *p;
 261
 262         g_return_val_if_fail(service != NULL, FALSE);
 263
 264         p = _ps_service_ref_plugin(service);
 265         s = tcore_plugin_ref_server(p);
 266
 267         tcore_server_add_notification_hook(s, TNOTI_NETWORK_REGISTRATION_STATUS, __on_hook_net_register, service);
 268         tcore_server_add_notification_hook(s, TNOTI_NETWORK_CHANGE, __on_hook_net_change, service);
 269
 270         return TRUE;
 271 }
 272
 273 gboolean _ps_get_co_network_values(gpointer service)
 274 {
 275         CoreObject *co_network = NULL;
 276         gboolean ps_attached = FALSE;
 277
 278         enum telephony_network_service_domain_status ps_status;
 279         enum telephony_network_access_technology act;
 280
 281         g_return_val_if_fail(service != NULL, FALSE);
 282
 283         co_network = _ps_service_ref_co_network(service);
 284
 285         tcore_network_get_service_status(co_network, TCORE_NETWORK_SERVICE_DOMAIN_TYPE_PACKET, &ps_status);
 286         tcore_network_get_access_technology(co_network, &act);
 287
 288         if (ps_status == NETWORK_SERVICE_DOMAIN_STATUS_FULL)
 289                 ps_attached = TRUE;
 290
 291         _ps_service_set_roaming(service, tcore_network_get_roaming_state(co_network));
 292         _ps_service_set_ps_attached(service, ps_attached);
 293         _ps_service_set_access_technology(service, act);
 294
 295         return TRUE;
 296 }
 297
 298 gboolean _ps_hook_co_ps_event(gpointer service)
 299 {
 300         Server *s = NULL;
 301         TcorePlugin *p;
 302         g_return_val_if_fail(service != NULL, FALSE);
 303
 304         p = _ps_service_ref_plugin(service);
 305         s = tcore_plugin_ref_server(p);
 306
 307         tcore_server_add_notification_hook(s, TNOTI_PS_CALL_STATUS, __on_hook_call_status, service);
 308         tcore_server_add_notification_hook(s, TNOTI_PS_CURRENT_SESSION_DATA_COUNTER, __on_hook_session_data_counter, service);
 309         tcore_server_add_notification_hook(s, TNOTI_PS_PDP_IPCONFIGURATION, __on_hook_ipconfiguration, service);
 310
 311         return TRUE;
 312 }
 313
 314 gboolean _ps_free_co_ps_event(gpointer service)
 315 {
 316         Server *s = NULL;
 317         TcorePlugin *p;
 318         g_return_val_if_fail(service != NULL, FALSE);
 319
 320         p = _ps_service_ref_plugin(service);
 321         s = tcore_plugin_ref_server(p);
 322
 323         tcore_server_remove_notification_hook(s, __on_hook_call_status);
 324         tcore_server_remove_notification_hook(s, __on_hook_session_data_counter);
 325         tcore_server_remove_notification_hook(s, __on_hook_ipconfiguration);
 326
 327         return TRUE;
 328 }
 329
 330 gboolean _ps_free_co_network_event(gpointer service)
 331 {
 332         Server *s = NULL;
 333         TcorePlugin *p;
 334         g_return_val_if_fail(service != NULL, FALSE);
 335
 336         p = _ps_service_ref_plugin(service);
 337         s = tcore_plugin_ref_server(p);
 338
 339         tcore_server_remove_notification_hook(s, __on_hook_net_register);
 340         tcore_server_remove_notification_hook(s, __on_hook_net_change);
 341
 342         return TRUE;
 343 }
 344
 345 gboolean _ps_update_cellular_state_key(gpointer service)
 346 {
 347         Server *s = NULL;
 348         gpointer handle = NULL;
 349         static Storage *strg;
 350         int err_reason = 0;
 351
 352         s = tcore_plugin_ref_server( (TcorePlugin *)_ps_service_ref_plugin(service) );
 353         strg = tcore_server_find_storage(s, "vconf");
 354         handle = tcore_storage_create_handle(strg, "vconf");
 355         if (!handle){
 356                 err("fail to create vconf handle");
 357                 return FALSE;
 358         }
 359
 360         err_reason = _ps_service_check_cellular_state(service);
 361         tcore_storage_set_int(strg,STORAGE_KEY_CELLULAR_STATE, err_reason);
 362
 363         return TRUE;
 364 }