src/manager_core.c

   1 /*
   2  * tel-plugin-manager
   3  *
   4  * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Suresh Kumar N <suresh.n@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */
  20
  21 #include <glib.h>
  22 #include <tcore.h>
  23 #include <manager.h>
  24 #include <plugin.h>
  25 #include <server.h>
  26
  27 #include "manager_core.h"
  28 #include "manager_request.h"
  29 #include "manager_notification.h"
  30 #include "manager_queue.h"
  31 #include "manager_network.h"
  32 #include "manager_sim.h"
  33 #include "manager_call.h"
  34 #include "manager_modem.h"
  35 #include "internal/manager_internal.h"
  36
  37 static void __create_modem_board_sub_modules(ModemBoard *mb)
  38 {
  39         dbg("enter");
  40         /* Initialize network private info cache */
  41         manager_network_initialize_private_info(mb);
  42
  43         /*Initialize call private info cache*/
  44         manager_call_initialize_private_info(mb);
  45         manager_sim_initialize_private_info(mb);
  46         manager_modem_initialize_private_info(mb);
  47 }
  48
  49 static void __destroy_modem_board_sub_modules(ModemBoard *mb)
  50 {
  51         dbg("enter");
  52         /* Clear network private info cache */
  53         manager_network_clear_private_info(mb);
  54         manager_modem_clear_private_info(mb);
  55 }
  56
  57 void manager_core_create_modem_board(TcorePlugin *manager_plugin, TcorePlugin *modem_plugin)
  58 {
  59         ModemBoard *mb = NULL;
  60         GSList *list = NULL;
  61         ModemBoardIndex index = manager_core_get_modem_board_index(modem_plugin);
  62         PrivateData *priv_data = tcore_plugin_ref_user_data(manager_plugin);
  63
  64         if (G_UNLIKELY(!priv_data))
  65                 return;
  66
  67         if (index == MANAGER_MODEM_BOARD_INDEX_INVALID) {
  68                 warn("Wrong Modem Index");
  69                 return;
  70         }
  71
  72         /* Check Duplicated */
  73         for (list = priv_data->board_list; list; list = list->next) {
  74                 mb = list->data;
  75                 if (G_UNLIKELY(!mb))
  76                         continue;
  77
  78                 if (mb->index == index) {
  79                         warn("We already have Modem Index(%d)", index);
  80                         return;
  81                 }
  82         }
  83
  84         /* Create Modem Board */
  85         mb = g_try_malloc0(sizeof(ModemBoard));
  86         if (mb == NULL) {
  87                 err("Memory alloc failed");
  88                 return;
  89         }
  90
  91         mb->index = index;
  92         mb->modem_plugin = modem_plugin;
  93         mb->fdn_enabled = FALSE;
  94         mb->fdn_contacts = NULL;
  95         priv_data->board_list = g_slist_append(priv_data->board_list, mb);
  96
  97         __create_modem_board_sub_modules(mb);
  98         dbg("modem (%d) added, so modem board(%p) added", index, mb);
  99 }
 100
 101 void manager_core_destroy_modem_board(TcorePlugin *manager_plugin, TcorePlugin *modem_plugin)
 102 {
 103         ModemBoard *mb = NULL;
 104         GSList *list = NULL;
 105         PrivateData *priv_data = tcore_plugin_ref_user_data(manager_plugin);
 106
 107         if (G_UNLIKELY(!priv_data))
 108                 return;
 109
 110         /* Traverse through mb list and destroy matching mb */
 111         for (list = priv_data->board_list; list; list = list->next) {
 112                 mb = list->data;
 113                 if (G_UNLIKELY(!mb))
 114                         continue;
 115
 116                 if (mb->modem_plugin == modem_plugin) {
 117                         dbg("modem(%d) removed, so blackboard(%p) removed", mb->index, mb);
 118                         __destroy_modem_board_sub_modules(mb);
 119                         priv_data->board_list = g_slist_remove(priv_data->board_list, mb);
 120                         break;
 121                 }
 122
 123                 if (TRUE == mb->fdn_enabled && mb->fdn_contacts)
 124                         g_hash_table_destroy(mb->fdn_contacts);
 125                 mb->fdn_contacts = NULL;
 126         }
 127 }
 128
 129 ModemBoard *manager_core_get_modem_board(Manager *manager, TcorePlugin *modem_plugin)
 130 {
 131         GSList *list = NULL;
 132         TcorePlugin *manager_plugin = tcore_manager_get_plugin(manager);
 133         PrivateData *priv_data = tcore_plugin_ref_user_data(manager_plugin);
 134
 135         if (G_UNLIKELY(!priv_data))
 136                 return NULL;
 137
 138         for (list = priv_data->board_list; list; list = list->next) {
 139                 ModemBoard *mb = list->data;
 140                 if (G_UNLIKELY(!mb))
 141                         continue;
 142                 if (mb->modem_plugin == modem_plugin) {
 143                         dbg("modem(%d) selected. board(%p)", mb->index, mb);
 144                         return mb;
 145                 }
 146         }
 147         warn("Cannot find modem board");
 148         return NULL;
 149 }
 150
 151 ModemBoard *manager_core_get_modem_board_by_plugin(TcorePlugin *modem_plugin)
 152 {
 153         Server *server = tcore_plugin_ref_server(modem_plugin);
 154         Manager *manager = tcore_server_ref_manager(server);
 155
 156         return manager_core_get_modem_board(manager, modem_plugin);
 157 }
 158
 159 ModemBoardIndex manager_core_get_modem_board_index(TcorePlugin *modem_plugin)
 160 {
 161         const char *cp_name = tcore_server_get_cp_name_by_plugin(modem_plugin);
 162
 163         if (g_str_has_suffix((const gchar *)cp_name, "0"))
 164                 return MANAGER_MODEM_BOARD_INDEX_0;
 165         else if (g_str_has_suffix((const gchar *)cp_name, "1"))
 166                 return MANAGER_MODEM_BOARD_INDEX_1;
 167         else
 168                 return MANAGER_MODEM_BOARD_INDEX_INVALID;
 169 }
 170
 171 /* Create list for already existing modem plugin's that were present before manager intialization */
 172 void manager_core_create_modem_board_list(TcorePlugin *manager_plugin)
 173 {
 174         Server *s = tcore_plugin_ref_server(manager_plugin);
 175         GSList *list = NULL;
 176         GSList *modem_plugin_list = tcore_server_get_modem_plugin_list(s);
 177
 178         if (G_UNLIKELY(!modem_plugin_list))
 179                 return;
 180
 181         /* Traverse through each modem plugin and create mb */
 182         for (list = modem_plugin_list; list; list = list->next) {
 183                 TcorePlugin *modem_plugin = list->data;
 184                 if (modem_plugin)
 185                         manager_core_create_modem_board(manager_plugin, modem_plugin);
 186         }
 187
 188         g_slist_free(modem_plugin_list);
 189 }
 190
 191 void manager_core_destroy_modem_board_list(TcorePlugin *manager_plugin)
 192 {
 193         Server *s = tcore_plugin_ref_server(manager_plugin);
 194         GSList *list = NULL;
 195         GSList *modem_plugin_list = tcore_server_get_modem_plugin_list(s);
 196
 197         if (G_UNLIKELY(!modem_plugin_list))
 198                 return;
 199
 200         /* Traverse through each modem plugin and destroy mb */
 201         for (list = modem_plugin_list; list; list = list->next) {
 202                 TcorePlugin *modem_plugin = list->data;
 203                 if (modem_plugin)
 204                         manager_core_destroy_modem_board(manager_plugin, modem_plugin);
 205         }
 206         g_slist_free(modem_plugin_list);
 207 }
 208
 209 /* Core initializer */
 210 gboolean manager_core_init(TcorePlugin *plugin)
 211 {
 212         Manager *manager;
 213         PrivateData *priv_data = NULL;
 214
 215         /* Create manager */
 216         manager = tcore_manager_new(plugin);
 217
 218         /*
 219          * Set handlers -
 220          *    Request dispatcher
 221          *    Notification handler
 222          */
 223         if (tcore_manager_set_request_dispatcher(manager,
 224                                                  manager_request_handler) != TCORE_RETURN_SUCCESS) {
 225                 err("Failed to set Request dispatcher");
 226                 goto ERROR;
 227         }
 228
 229         if (tcore_manager_set_notification_handler(manager,
 230                                                    manager_notification_handler) != TCORE_RETURN_SUCCESS) {
 231                 err("Failed to set Notification handler");
 232                 goto ERROR;
 233         }
 234
 235         /* Private data for Manager plug-in */
 236         priv_data = g_malloc0(sizeof(PrivateData));
 237         if (!priv_data)
 238                 goto ERROR;
 239
 240         /* Link private data to plug-in */
 241         tcore_plugin_link_user_data(plugin, priv_data);
 242
 243         /* Update Manager */
 244         priv_data->manager = manager;
 245         priv_data->board_list = NULL;
 246
 247         /* Flag to track dial initiated or not for MO/MT synchronization */
 248         priv_data->is_dial_initiated = FALSE;
 249
 250         /* Flag to consume end notification when internal end request is raised for MO/MT synchronization */
 251         priv_data->is_end_initiated = FALSE;
 252
 253         /*Flag to identify if boot is completed*/
 254         priv_data->boot_config_completed = FALSE;
 255
 256         /* Flag to identify if end all request processing is ongoing due to flight mode enable*/
 257         priv_data->is_end_all_initiated = FALSE;
 258
 259         /*Flag to identify if dial notification is already sent in case of Emergency call*/
 260         priv_data->is_dial_noti_sent = FALSE;
 261
 262         /* Create manager modem balckboard cache */
 263         manager_core_create_modem_board_list(plugin);
 264
 265         /* Create and initialize Manager queue */
 266         priv_data->manager_queue = manager_queue_init();
 267         if (G_UNLIKELY(priv_data->manager_queue == NULL)) {
 268                 err("Failed to create Manager queue");
 269                 goto ERROR;
 270         }
 271
 272         return TRUE;
 273
 274  ERROR:
 275         /* Free resource */
 276         g_free(priv_data);
 277
 278         /* Destroy manager */
 279         tcore_manager_free(plugin, manager);
 280
 281         return FALSE;
 282 }
 283
 284 /* Core de-initializer */
 285 void manager_core_deinit(TcorePlugin *plugin)
 286 {
 287         PrivateData *priv_data;
 288
 289         priv_data = tcore_plugin_ref_user_data(plugin);
 290         if (priv_data != NULL) {
 291                 /* Destroy manager */
 292                 tcore_manager_free(plugin, priv_data->manager);
 293
 294                 /* Clear and free Manager queue */
 295                 manager_queue_deinit(priv_data->manager_queue);
 296
 297                 /* Destroy manager modem balckboard cache */
 298                 manager_core_destroy_modem_board_list(plugin);
 299
 300                 /* Free private data */
 301                 g_free(priv_data);
 302                 tcore_plugin_link_user_data(plugin, NULL);
 303         }
 304 }