call-engine/core/vc-core-engine-status.c

   1 /*
   2  * Copyright 2012  Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.tizenopensource.org/license
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17
  18 /* Call Module File Includes */
  19 #include "vc-core-engine.h"
  20 #include "vc-core-callagent.h"
  21 #include "vc-core-callmanager.h"
  22 #include "vc-core-util.h"
  23 #include "vc-core-tapi-evnt.h"
  24 #include "vc-core-tapi-rqst.h"
  25 #include "vc-core-svcall.h"
  26 #include "vc-core-engine-status.h"
  27
  28 /**
  29 * This function checks whether the given incoming call is a restricted call or not
  30 *
  31 * @return               ERROR_VOICECALL_NONE on success or return value contains appropriate error code on failure
  32 * @param[in]    pvoicecall_agent        Handle to voicecall engine
  33 * @param[in]    call_handle             Call handle of the call to be checked
  34 * @param[out]   pbrestricted            Pointer to the restricted name mode
  35 * @remarks              pvoicecall_agent and prestricted cannot be NULL.
  36 *                               This API shall only be used with the incoming call handle before it is connected
  37 */
  38 voicecall_error_t _vc_core_engine_status_isrestricted_call(voicecall_engine_t *pvoicecall_agent, int call_handle, gboolean *pbrestricted)
  39 {
  40         call_vc_callagent_state_t *pagent = (call_vc_callagent_state_t *)pvoicecall_agent;
  41         call_vc_call_objectinfo_t call_object;
  42
  43         VOICECALL_RETURN_VALUE_IF_FAIL(pagent != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
  44         VOICECALL_RETURN_VALUE_IF_FAIL(call_handle >= 0, ERROR_VOICECALL_INVALID_ARGUMENTS);
  45         VOICECALL_RETURN_VALUE_IF_FAIL(pbrestricted != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
  46
  47         _vc_core_cm_clear_call_object(&call_object);
  48         if (TRUE == _vc_core_cm_get_call_object(&pagent->call_manager, call_handle, &call_object)) {
  49                 *pbrestricted = call_object.brestricted_namemode;
  50                 return ERROR_VOICECALL_NONE;
  51         }
  52
  53         *pbrestricted = FALSE;
  54         return ERROR_VOICECALL_CALL_INFO_NOT_AVAILABLE;
  55 }
  56
  57 /**
  58 * This function checks whether the given incoming call is a restricted call or not
  59 *
  60 * @return               ERROR_VOICECALL_NONE on success or return value contains appropriate error code on failure
  61 * @param[in]    pvoicecall_agent        Handle to voicecall engine
  62 * @param[in]    call_handle             Call handle of the call to be checked
  63 * @param[out]   pbrestricted            Pointer to the restricted name mode
  64 * @remarks              pvoicecall_agent and prestricted cannot be NULL.
  65 *                               This API shall only be used with the incoming call handle before it is connected
  66 */
  67 voicecall_error_t _vc_core_engine_status_get_calling_namemode(voicecall_engine_t *pvoicecall_agent, int call_handle, gboolean * bcalling_namemode)
  68 {
  69         call_vc_callagent_state_t *pagent = (call_vc_callagent_state_t *)pvoicecall_agent;
  70         call_vc_call_objectinfo_t call_object;
  71
  72         VOICECALL_RETURN_VALUE_IF_FAIL(pagent != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
  73         VOICECALL_RETURN_VALUE_IF_FAIL(call_handle >= 0, ERROR_VOICECALL_INVALID_ARGUMENTS);
  74         VOICECALL_RETURN_VALUE_IF_FAIL(bcalling_namemode != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
  75
  76         _vc_core_cm_clear_call_object(&call_object);
  77         if (TRUE == _vc_core_cm_get_call_object(&pagent->call_manager, call_handle, &call_object)) {
  78                 if (call_object.bcalling_namemode == CALL_VC_CALLING_NAME_MODE_AVAILABLE) {
  79                         *bcalling_namemode = TRUE;
  80                 } else {
  81                         *bcalling_namemode = FALSE;
  82                 }
  83                 return ERROR_VOICECALL_NONE;
  84         }
  85
  86         *bcalling_namemode = FALSE;
  87         return ERROR_VOICECALL_CALL_INFO_NOT_AVAILABLE;
  88 }
  89
  90 /**
  91 * This function retrieves the call object belongs to the given call handle
  92 *
  93 * @return               ERROR_VOICECALL_NONE on success or return value contains appropriate error code on failure
  94 * @param[in]    pvoicecall_agent        Handle to voicecall engine
  95 * @param[in]    call_handle     Call handle of the call for which the call object is retrieved
  96 * @param[out]   pcall_object    Pointer to the retrived call object info
  97 * @remarks              pvoicecall_agent and pcall_object cannot be NULL.
  98 */
  99 voicecall_error_t _vc_core_engine_status_get_call_object(voicecall_engine_t *pvoicecall_agent, int call_handle, call_vc_call_objectinfo_t *pcall_object)
 100 {
 101         call_vc_callagent_state_t *pagent = (call_vc_callagent_state_t *)pvoicecall_agent;
 102         VOICECALL_RETURN_VALUE_IF_FAIL(pagent != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 103         VOICECALL_RETURN_VALUE_IF_FAIL(call_handle >= 0, ERROR_VOICECALL_INVALID_ARGUMENTS);
 104         VOICECALL_RETURN_VALUE_IF_FAIL(pcall_object != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 105
 106         /*Clear the call object */
 107         _vc_core_cm_clear_call_object(pcall_object);
 108
 109         if (TRUE == _vc_core_cm_get_call_object(&pagent->call_manager, call_handle, pcall_object)) {
 110                 return ERROR_VOICECALL_NONE;
 111         }
 112
 113         pcall_object = NULL;
 114         return ERROR_VOICECALL_CALL_INFO_NOT_AVAILABLE;
 115 }
 116
 117 /**
 118 * This function retrieves the inout state of the engine
 119 *
 120 * @return               ERROR_VOICECALL_NONE on success or return value contains appropriate error code on failure
 121 * @param[in]    pvoicecall_agent        Handle to voicecall engine
 122 * @param[out]   pio_state                       Contains the Engine InOut state on return
 123 * @remarks              pvoicecall_agent and pio_state cannot be NULL.
 124 * @see                  _vc_core_engine_change_engine_iostate
 125 */
 126 voicecall_error_t _vc_core_engine_status_get_engine_iostate(voicecall_engine_t *pvoicecall_agent, int *pio_state)
 127 {
 128         call_vc_callagent_state_t *pagent = (call_vc_callagent_state_t *)pvoicecall_agent;
 129         VOICECALL_RETURN_VALUE_IF_FAIL(pagent != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 130         VOICECALL_RETURN_VALUE_IF_FAIL(pio_state != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 131
 132         *pio_state = pagent->io_state;
 133         CALL_ENG_DEBUG(ENG_DEBUG, "io_state = [%d]", pagent->io_state);
 134         return ERROR_VOICECALL_NONE;
 135 }
 136
 137 /**
 138 * This function checks whether connected call exists or not
 139 *
 140 * @return               ERROR_VOICECALL_NONE on success or return value contains appropriate error code on failure
 141 * @param[in]    pvoicecall_agent        Handle to voicecall engine
 142 * @param[in]    call_type                       call type
 143 * @param[out]   bcall_exists            TRUE - if call exists of given given type, FALSE otherwise
 144 * @remarks              pvoicecall_agent and bcall_exists cannot be NULL.
 145 */
 146 voicecall_error_t _vc_core_engine_status_isexists_call_bytype(voicecall_engine_t *pvoicecall_agent, voicecall_call_type_t call_type, gboolean *bcall_exists)
 147 {
 148         call_vc_callagent_state_t *pagent = (call_vc_callagent_state_t *)pvoicecall_agent;
 149         VOICECALL_RETURN_VALUE_IF_FAIL(pagent != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 150         VOICECALL_RETURN_VALUE_IF_FAIL(bcall_exists != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 151
 152         /*CALL_ENG_DEBUG(ENG_DEBUG,"call_type = %d", call_type);*/
 153         *bcall_exists = FALSE;
 154         switch (call_type) {
 155         case VC_INCOMING_CALL:
 156                 {
 157                         if (VC_INVALID_CALL_INDEX != pagent->call_manager.mtcall_index) {
 158                                 CALL_ENG_DEBUG(ENG_DEBUG, "incoming call exits...");
 159
 160                                 *bcall_exists = TRUE;
 161                                 return ERROR_VOICECALL_NONE;
 162                         }
 163                 }
 164                 break;
 165         case VC_OUTGOING_CALL:
 166                 {
 167                         if (VC_INVALID_CALL_INDEX != pagent->call_manager.setupcall_info.mocall_index) {
 168                                 CALL_ENG_DEBUG(ENG_DEBUG, "outgoing call exits...");
 169
 170                                 *bcall_exists = TRUE;
 171                                 return ERROR_VOICECALL_NONE;
 172                         }
 173                 }
 174                 break;
 175         case VC_CONNECTED_CALL:
 176                 {
 177                         *bcall_exists = _vc_core_cm_isexists_connected_call(&pagent->call_manager);
 178                         if (*bcall_exists == TRUE) {
 179                                 CALL_ENG_DEBUG(ENG_DEBUG, "connected call exits...");
 180                         }
 181                         return ERROR_VOICECALL_NONE;
 182                 }
 183                 break;
 184         default:
 185                 {
 186                         CALL_ENG_DEBUG(ENG_DEBUG, "Invalid call type..");
 187                         return ERROR_VOICECALL_INVALID_CALL_TYPE;
 188                 }
 189         }
 190
 191         return ERROR_VOICECALL_CALL_INFO_NOT_AVAILABLE;
 192 }
 193
 194 /**
 195 * This function retrieves the total number of call members currently available with the engine
 196 *
 197 * @return               ERROR_VOICECALL_NONE on success or return value contains appropriate error code on failure
 198 * @param[in]    pvoicecall_agent                Handle to voicecall engine
 199 * @param[out]   ptotal_call_member      Contains the total call member availalbe in engine on return
 200 * @remarks              pvoicecall_agent and ptotal_call_member cannot be NULL
 201 */
 202 voicecall_error_t _vc_core_engine_status_get_call_member_count(voicecall_engine_t *pvoicecall_agent, int *ptotal_call_member)
 203 {
 204         call_vc_callagent_state_t *pagent = (call_vc_callagent_state_t *)pvoicecall_agent;
 205         VOICECALL_RETURN_VALUE_IF_FAIL(pagent != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 206         VOICECALL_RETURN_VALUE_IF_FAIL(ptotal_call_member != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 207
 208         *ptotal_call_member = _vc_core_cm_get_call_member_count(&pagent->call_manager);
 209
 210         return ERROR_VOICECALL_NONE;
 211 }
 212
 213 /**
 214 * This function retrieves the total number of call members with the given connected call type
 215 *
 216 * @return               ERROR_VOICECALL_NONE on success or return value contains appropriate error code on failure
 217 * @param[in]    pvoicecall_agent                Handle to voicecall engine
 218 * @param[in]    connected_call_type     connected call type
 219 * @param[out]   pmember_num             Contains the number of call members available with the given connected call type on return
 220 * @remarks              pvoicecall_agent and pmember_num cannot be NULL
 221 */
 222 voicecall_error_t _vc_core_engine_status_get_call_member_info(voicecall_engine_t *pvoicecall_agent, voicecall_connected_call_type_t connected_call_type, int *pmember_num)
 223 {
 224         call_vc_callagent_state_t *pagent = (call_vc_callagent_state_t *)pvoicecall_agent;
 225         VOICECALL_RETURN_VALUE_IF_FAIL(pagent != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 226         VOICECALL_RETURN_VALUE_IF_FAIL(pmember_num != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 227
 228         switch (connected_call_type) {
 229         case VC_ACTIVE_CALL:
 230                 {
 231                         *pmember_num = _vc_core_cm_get_active_call_count(&pagent->call_manager);
 232                 }
 233                 break;
 234         case VC_HELD_CALL:
 235                 {
 236                         *pmember_num = _vc_core_cm_get_held_call_count(&pagent->call_manager);
 237                 }
 238                 break;
 239         default:
 240                 *pmember_num = 0;
 241                 return ERROR_VOICECALL_INVALID_CALL_TYPE;
 242         }
 243
 244         return ERROR_VOICECALL_NONE;
 245 }
 246
 247 /**
 248 * This function retrieves the call handle according to the given call type
 249 *
 250 * @return               ERROR_VOICECALL_NONE on success or return value contains appropriate error code on failure
 251 * @param[in]    pvoicecall_agent        Handle to voicecall engine
 252 * @param[in]    call_type               call type
 253 * @param[out]   pcall_handle            Contains the call handle on success
 254 * @remarks              pvoicecall_agent and pcall_handle cannot be NULL
 255 *                               In case of multiple connected calls available, it will retreive the first connected call
 256 */
 257 voicecall_error_t _vc_core_engine_status_get_call_handle_bytype(voicecall_engine_t *pvoicecall_agent, voicecall_call_type_t call_type, int *pcall_handle)
 258 {
 259         call_vc_callagent_state_t *pagent = (call_vc_callagent_state_t *)pvoicecall_agent;
 260         call_vc_manager_t *pcall_manager = NULL;
 261         call_vc_handle call_handle = -1;
 262
 263         VOICECALL_RETURN_VALUE_IF_FAIL(pagent != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 264         VOICECALL_RETURN_VALUE_IF_FAIL(pcall_handle != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 265
 266         pcall_manager = (call_vc_manager_t *) &pagent->call_manager;
 267
 268         switch (call_type) {
 269         case VC_INCOMING_CALL:
 270                 {
 271                         call_handle = _vc_core_cm_get_incoming_call_handle(pcall_manager);
 272                 }
 273                 break;
 274         case VC_OUTGOING_CALL:
 275                 {
 276                         call_handle = _vc_core_cm_get_outgoing_call_handle(pcall_manager);
 277                 }
 278                 break;
 279         case VC_CONNECTED_CALL:
 280                 {
 281                         _vc_core_cm_get_first_active_call_handle(pcall_manager, &call_handle);
 282                         if (-1 == call_handle) {
 283                                 _vc_core_cm_get_first_held_call_handle(pcall_manager, &call_handle);
 284                         }
 285                 }
 286                 break;
 287         default:
 288                 return ERROR_VOICECALL_INVALID_CALL_TYPE;
 289         }
 290
 291         if (-1 == call_handle) {
 292                 return ERROR_VOICECALL_CALL_INFO_NOT_AVAILABLE;
 293         }
 294
 295         *pcall_handle = call_handle;
 296         return ERROR_VOICECALL_NONE;
 297 }
 298
 299 /**
 300 * This function checks if active calls and/or held call exists or not
 301 *
 302 * @return               ERROR_VOICECALL_NONE on success or return value contains appropriate error code on failure
 303 * @param[in]    pvoicecall_agent        Handle to voicecall engine
 304 * @param[out]   pactive_calls           Set to TRUE if active calls exist
 305 * @param[out]   pheld_calls             Set to TRUE if held calls exist
 306 * @remarks              pvoicecall_agent,pactive_calls and pheld_calls cannot be NULL
 307 */
 308 voicecall_error_t _vc_core_engine_status_isexists_any_call(voicecall_engine_t *pvoicecall_agent, gboolean *pactive_calls, gboolean *pheld_calls)
 309 {
 310         call_vc_callagent_state_t *pagent = (call_vc_callagent_state_t *)pvoicecall_agent;
 311         call_vc_manager_t *pcall_manager = NULL;
 312
 313         VOICECALL_RETURN_VALUE_IF_FAIL(pagent != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 314         VOICECALL_RETURN_VALUE_IF_FAIL(pactive_calls != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 315         VOICECALL_RETURN_VALUE_IF_FAIL(pheld_calls != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 316
 317         pcall_manager = &pagent->call_manager;
 318
 319         *pactive_calls = _vc_core_cm_isexists_active_call(pcall_manager);
 320         *pheld_calls = _vc_core_cm_isexists_held_call(pcall_manager);
 321
 322         return ERROR_VOICECALL_NONE;
 323 }
 324
 325 /**
 326 * This function retreives the cphs csp status
 327 *
 328 * @return               ERROR_VOICECALL_NONE on success or return value contains appropriate error code on failure
 329 * @param[in]            pvoicecall_agent                Handle to Voicecall Engine
 330 * @param[in]            csp_service             csp name
 331 * @param[out]   pbcsp_status            Contains TRUE if given csp service is enabled,FALSE  otherwise
 332 * @remarks              pvoicecall_agent and pbcsp_status cannot be NULL
 333 */
 334 voicecall_error_t _vc_core_engine_status_get_cphs_csp_status(voicecall_engine_t *pvoicecall_agent, voicecall_cphs_csp_service csp_service, gboolean *pbcsp_status)
 335 {
 336         call_vc_callagent_state_t *pcall_agent = (call_vc_callagent_state_t *)pvoicecall_agent;
 337         VOICECALL_RETURN_VALUE_IF_FAIL(pcall_agent != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 338         VOICECALL_RETURN_VALUE_IF_FAIL(pbcsp_status != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 339 #ifdef _CPHS_DEFINED_
 340         *pbcsp_status = _vc_core_svcall_cphs_csp_get_status(pcall_agent, csp_service);
 341 #else
 342         *pbcsp_status = (VC_CPHS_CSP_ALS == csp_service) ? FALSE : TRUE;
 343 #endif
 344         return ERROR_VOICECALL_NONE;
 345 }
 346
 347 /**
 348 * This function checks if the call is emergency call for the given outgoing call index
 349 *
 350 * @return               ERROR_VOICECALL_NONE on success or return value contains appropriate error code on failure
 351 * @param[in]            pvoicecall_agent        Handle to Voicecall Engine
 352 * @param[in]            mo_call_index           Index of the outgoing call
 353 * @param[out]   pbemergency_call        Contains TRUE if the call is emergency call,FALSE  otherwise
 354 * @remarks              pvoicecall_agent and pbemergency_call cannot be NULL
 355 */
 356 voicecall_error_t _vc_core_engine_status_check_emergency_byindex(voicecall_engine_t *pvoicecall_agent, int mo_call_index, gboolean *pbemergency_call)
 357 {
 358         call_vc_callagent_state_t *pagent = (call_vc_callagent_state_t *)pvoicecall_agent;
 359         call_vc_manager_t *pcall_manager = NULL;
 360
 361         VOICECALL_RETURN_VALUE_IF_FAIL(pagent != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 362         VOICECALL_RETURN_VALUE_IF_FAIL(pbemergency_call != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 363         VOICECALL_RETURN_VALUE_IF_NOT_IN_RANGE(mo_call_index, 0, 7, ERROR_VOICECALL_INVALID_ARGUMENTS);
 364
 365         /*Assign Default Value */
 366         *pbemergency_call = FALSE;
 367
 368         pcall_manager = (call_vc_manager_t *) &pagent->call_manager;
 369
 370         CALL_VC_DUMP_CALLDETAILS(pcall_manager);
 371         CALL_ENG_DEBUG(ENG_DEBUG, "call_index = %d, bemergency_number = %d", mo_call_index, pcall_manager->callobject_info[mo_call_index].bemergency_number);
 372
 373         *pbemergency_call = pcall_manager->callobject_info[mo_call_index].bemergency_number;
 374         return ERROR_VOICECALL_NONE;
 375 }
 376
 377 /**
 378 * This function checks and returns the FDN status
 379 *
 380 * @return               ERROR_VOICECALL_NONE on success or return value contains appropriate error code on failure
 381 * @param[in]            pcall_agent     Handle to Voicecall Engine - Currently not used, reserved for future use
 382 * @param[out]   bfdn_enabled    TRUE - if FDN is enabled, FALSE  otherwise
 383 * @remarks              pvoicecall_agent and bfdn_anabled cannot be NULL
 384 */
 385 voicecall_error_t _vc_core_engine_status_isenabled_fdn(voicecall_engine_t *pcall_agent, gboolean *bfdn_enabled)
 386 {
 387         gboolean bfdn = FALSE;
 388         VOICECALL_RETURN_VALUE_IF_FAIL(bfdn_enabled != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 389         VOICECALL_RETURN_VALUE_IF_FAIL(pcall_agent != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 390
 391         CALL_ENG_KPI("tel_get_sim_fdn_status start");
 392         if (TAPI_API_SUCCESS == tel_get_sim_fdn_status(&bfdn)) {
 393                 *bfdn_enabled = bfdn;
 394                 return ERROR_VOICECALL_NONE;
 395         }
 396         CALL_ENG_KPI("tel_get_sim_fdn_status done");
 397
 398         *bfdn_enabled = FALSE;
 399         return ERROR_VOICECALL_TAPI_ERROR;
 400 }
 401
 402 /**
 403 * This function checks the possiblity of transfering calls
 404 *
 405 * @return               ERROR_VOICECALL_NONE on success or return value contains appropriate error code on failure
 406 * @param[in]            pvoicecall_agent        Handle to Voicecall Engine
 407 * @param[out]   pbtransfer_calls        Contains TRUE if call transfer is possible, FALSE otherwise
 408 * @remarks              pvoicecall_agent and pbtransfer_calls cannot be NULL
 409 */
 410 voicecall_error_t _vc_core_engine_status_is_transfer_call_possible(voicecall_engine_t *pvoicecall_agent, gboolean *pbtransfer_calls)
 411 {
 412         call_vc_callagent_state_t *pcall_agent = (call_vc_callagent_state_t *)pvoicecall_agent;
 413
 414         VOICECALL_RETURN_VALUE_IF_FAIL(pcall_agent != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 415         VOICECALL_RETURN_VALUE_IF_FAIL(pbtransfer_calls != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 416
 417         *pbtransfer_calls = _vc_core_ca_is_transfer_call_possible(pcall_agent);
 418
 419         return ERROR_VOICECALL_NONE;
 420 }
 421
 422 /**
 423 * This function checks the possiblity of making conference calls
 424 *
 425 * @return               ERROR_VOICECALL_NONE on success or return value contains appropriate error code on failure
 426 * @param[in]            pvoicecall_agent        Handle to Voicecall Engine
 427 * @param[out]   pbconf_call             Contains TRUE if conference call is possible , FALSE otherwise
 428 * @remarks              pvoicecall_agent and pbconf_call cannot be NULL
 429 */
 430 voicecall_error_t _vc_core_engine_status_is_conf_call_possible(voicecall_engine_t *pvoicecall_agent, gboolean *pbconf_call)
 431 {
 432         call_vc_callagent_state_t *pcall_agent = (call_vc_callagent_state_t *)pvoicecall_agent;
 433         gboolean active_calls = FALSE;
 434         gboolean held_calls = FALSE;
 435         int total_call_member = 0;
 436         gboolean bconf = FALSE;
 437
 438         VOICECALL_RETURN_VALUE_IF_FAIL(pcall_agent != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 439         VOICECALL_RETURN_VALUE_IF_FAIL(pbconf_call != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 440
 441 #ifdef _CPHS_DEFINED_
 442         if (_vc_core_svcall_cphs_csp_get_status(pcall_agent, VC_CPHS_CSP_MPTY)) {
 443                 CALL_ENG_DEBUG(ENG_DEBUG, "_vc_core_svcall_cphs_csp_get_status returned TRUE");
 444                 *pbconf_call = TRUE;
 445         } else {
 446                 *pbconf_call = FALSE;
 447                 return ERROR_VOICECALL_NONE;
 448         }
 449 #endif
 450
 451         _vc_core_cm_isexists_call_ingroup(&pcall_agent->call_manager, &active_calls, &held_calls);
 452         total_call_member = _vc_core_cm_get_call_member_count(&pcall_agent->call_manager);
 453
 454         /* Joining call is impossile when !active or !hold call exist */
 455         if (!active_calls || !held_calls) {
 456                 CALL_ENG_DEBUG(ENG_DEBUG, "Join Impossible...");
 457                 bconf = FALSE;
 458         } else {
 459                 /* Joining call is impossile when member is more than max
 460                 Max Number in Group + Another Call*/
 461                 if (total_call_member >= (VC_MAX_CALL_GROUP_MEMBER + 1)) {
 462                         CALL_ENG_DEBUG(ENG_DEBUG, "Ended with FALSE...");
 463                         bconf = FALSE;
 464                 } else {
 465                         CALL_ENG_DEBUG(ENG_DEBUG, "Ended with TRUE...");
 466                         bconf = TRUE;
 467                 }
 468         }
 469
 470         *pbconf_call = bconf;
 471         return ERROR_VOICECALL_NONE;
 472
 473 }
 474
 475 /**
 476 * This function retreives the call state of the given call
 477 *
 478 * @return               ERROR_VOICECALL_NONE on success or return value contains appropriate error code on failure
 479 * @param[in]    pvoicecall_agent        Handle to voicecall engine
 480 * @param[in]    call_handle             Call handle of particular call
 481 * @param[out]   pcall_state             Contains the call state of the given call handle
 482 * @remarks              pvoicecall_agent and pcall_state cannot be NULL
 483 */
 484 voicecall_error_t _vc_core_engine_status_get_call_state_byhandle(voicecall_engine_t *pvoicecall_agent, int call_handle, voicecall_call_state_t *pcall_state)
 485 {
 486         call_vc_callagent_state_t *pagent = (call_vc_callagent_state_t *)pvoicecall_agent;
 487         call_vc_call_objectinfo_t call_object = { 0 };
 488
 489         VOICECALL_RETURN_VALUE_IF_FAIL(pagent != NULL, ERROR_VOICECALL_INVALID_CALL_HANDLE);
 490         VOICECALL_RETURN_VALUE_IF_FAIL(pcall_state != NULL, ERROR_VOICECALL_INVALID_CALL_HANDLE);
 491         VOICECALL_RETURN_VALUE_IF_FAIL(call_handle >= 0, ERROR_VOICECALL_INVALID_CALL_HANDLE);
 492
 493         _vc_core_cm_clear_call_object(&call_object);
 494         if (TRUE == _vc_core_cm_get_call_object(&pagent->call_manager, call_handle, &call_object)) {
 495                 *pcall_state = call_object.state;
 496                 return ERROR_VOICECALL_NONE;
 497         }
 498
 499         *pcall_state = VC_CALL_STATE_NONE;
 500         return ERROR_VOICECALL_CALL_INFO_NOT_AVAILABLE;
 501 }
 502
 503 #if     0       /*unused*/
 504 /**
 505 * This function retrieves call handle of the any one of the calls of given type
 506 *
 507 * @return               ERROR_VOICECALL_NONE on success or return value contains appropriate error code on failure
 508 * @param[in]    pvoicecall_agent                Handle to voicecall engine
 509 * @param[in]    connected_call_type     Connected call type
 510 * @param[out]   pcall_handle                    Contains the Call handle on return
 511 * @remarks              pvoicecall_agent and pcall_handle cannot be NULL
 512 */
 513 voicecall_error_t voicecall_get_any_call_handle(voicecall_engine_t *pvoicecall_agent, voicecall_connected_call_type_t connected_call_type, int *pcall_handle)
 514 {
 515         call_vc_callagent_state_t *pagent = (call_vc_callagent_state_t *)pvoicecall_agent;
 516         call_vc_handle callhandle = -1;
 517
 518         VOICECALL_RETURN_VALUE_IF_FAIL(pagent != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 519         VOICECALL_RETURN_VALUE_IF_FAIL(pcall_handle != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 520
 521         switch (connected_call_type) {
 522         case VC_ACTIVE_CALL:
 523                 {
 524                         _vc_core_cm_get_first_active_call_handle(&pagent->call_manager, &callhandle);
 525                 }
 526                 break;
 527         case VC_HELD_CALL:
 528                 {
 529                         _vc_core_cm_get_first_held_call_handle(&pagent->call_manager, &callhandle);
 530                 }
 531                 break;
 532         default:
 533                 return ERROR_VOICECALL_INVALID_CALL_TYPE;
 534         }
 535
 536         if (-1 != callhandle) {
 537                 *pcall_handle = (int)callhandle;
 538                 return ERROR_VOICECALL_NONE;
 539         }
 540
 541         return ERROR_VOICECALL_CALL_INFO_NOT_AVAILABLE;
 542 }
 543 #endif
 544
 545 /**
 546 * This function checks if any call is ending and retrieves its call number if it is ending
 547 *
 548 * @return               ERROR_VOICECALL_NONE on success or return value contains appropriate error code on failure
 549 * @param[in]    pvoicecall_agent        Handle to voicecall engine
 550 * @param[out]   bcall_ending            TRUE if any call is being ended, FALSE otherwise
 551 * @remarks              pvoicecall_agent and bcall_ending cannot be NULL
 552 */
 553 voicecall_error_t _vc_core_engine_status_is_any_call_ending(voicecall_engine_t *pvoicecall_agent, gboolean *bcall_ending)
 554 {
 555         call_vc_callagent_state_t *pagent = (call_vc_callagent_state_t *)pvoicecall_agent;
 556
 557         VOICECALL_RETURN_VALUE_IF_FAIL(pagent != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 558         VOICECALL_RETURN_VALUE_IF_FAIL(bcall_ending != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 559
 560         *bcall_ending = FALSE;
 561         *bcall_ending = _vc_core_cm_get_ending_call_info(&pagent->call_manager);
 562
 563         return ERROR_VOICECALL_NONE;
 564 }
 565
 566 /**
 567 * This function checks whther engine is busy in processing any events or waiting for any events to process
 568 *
 569 * @return               ERROR_VOICECALL_NONE on success or return value contains appropriate error code on failure
 570 * @param[in]    pvoicecall_agent        Handle to voicecall engine
 571 * @param[out]   bbusy   TRUE - if engine is busy in processing any events or waiting for any events, FALSE - otherwise
 572 * @remarks              pvoicecall_agent and bbusy cannot be NULL
 573 */
 574 voicecall_error_t _vc_core_engine_status_is_engine_busy(voicecall_engine_t *pvoicecall_agent, gboolean *bbusy)
 575 {
 576         call_vc_callagent_state_t *pagent = (call_vc_callagent_state_t *)pvoicecall_agent;
 577         VOICECALL_RETURN_VALUE_IF_FAIL(pagent != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 578         VOICECALL_RETURN_VALUE_IF_FAIL(bbusy != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 579
 580         CALL_ENG_DEBUG(ENG_DEBUG, "Current Call Agent State:%d", pagent->callagent_state);
 581         if (CALL_VC_CA_STATE_NORMAL == pagent->callagent_state) {
 582                 *bbusy = FALSE;
 583         } else {
 584                 *bbusy = TRUE;
 585         }
 586
 587         return ERROR_VOICECALL_NONE;
 588 }
 589
 590 /**
 591 * This function sets the given flag to engine for processing during call end.
 592 * This function has to be used after calling the end call API
 593 *
 594 * @return               ERROR_VOICECALL_NONE on success or return value contains appropriate error code on failure
 595 * @param[in]    pvoicecall_agent        Handle to voicecall engine
 596 * @param[in]    end_flag                        End Flag to be set
 597 * @remarks              pvoicecall_agent and bsscode cannot be NULL
 598 */
 599 voicecall_error_t _vc_core_engine_status_set_end_flag(voicecall_engine_t *pvoicecall_agent, voicecall_end_flag_t end_flag)
 600 {
 601         call_vc_callagent_state_t *pagent = (call_vc_callagent_state_t *)pvoicecall_agent;
 602
 603         VOICECALL_RETURN_VALUE_IF_FAIL(pagent != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 604
 605         switch (end_flag) {
 606         case VC_RETREIVE_CALL_ON_MOCALL_END:
 607                 {
 608                         pagent->callagent_state = CALL_VC_CA_STATE_SS_WAIT_RELEASE_ALL_ACTIVECALL;
 609                 }
 610                 break;
 611         default:
 612                 return ERROR_VOICECALL_INVALID_ARGUMENTS;
 613         }
 614
 615         return ERROR_VOICECALL_NONE;
 616 }
 617
 618 /**
 619 * This function checks whether the given string is MMI string or not
 620 *
 621 * @return               ERROR_VOICECALL_NONE on success or return value contains appropriate error code on failure
 622 * @param[in]    pvoicecall_agent        Handle to voicecall engine
 623 * @param[in]    pinput_number   Input string to be verified
 624 * @param[out]   bsscode                 TRUE - if the given string is a valid ss code, FALSE otherwise
 625 * @remarks              pvoicecall_agent and bsscode cannot be NULL
 626 */
 627 voicecall_error_t _vc_core_engine_status_isvalid_ss_code(voicecall_engine_t *pvoicecall_agent, const char *pinput_number, gboolean *bsscode)
 628 {
 629         int strLen = 0;
 630         call_vc_ss_si_format si_format = SS_SI_FORMAT_INVALID;
 631
 632         VOICECALL_RETURN_VALUE_IF_FAIL(pvoicecall_agent != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 633         VOICECALL_RETURN_VALUE_IF_FAIL(pinput_number != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 634         VOICECALL_RETURN_VALUE_IF_FAIL(bsscode != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 635
 636         si_format = SS_SI_FORMAT_VALID;
 637         strLen = strlen(pinput_number);
 638
 639         CALL_ENG_DEBUG(ENG_DEBUG, "strLen = %d", strLen);
 640
 641         if (strLen > 2) {
 642                 /* Deactivate :  "#...#" */
 643                 /* Erase :               "##...#" */
 644                 if (((pinput_number[0] == '#') && (pinput_number[strLen - 1] == '#')) || ((pinput_number[0] == '+') && (pinput_number[1] == '#') && (pinput_number[strLen - 1] == '#'))) {
 645                         si_format = _vc_core_util_check_si_format(pinput_number);
 646                         *bsscode = TRUE;
 647                         return ERROR_VOICECALL_NONE;
 648                 }
 649
 650                 /* Activate :           "*...#" */
 651                 /* Interrogate :        "*#...#" */
 652                 /* Register :           "**...#" */
 653                 if ((('*' == pinput_number[0]) && ('#' == pinput_number[strLen - 1])) || (('+' == pinput_number[0]) && ('*' == pinput_number[1]) && ('#' == pinput_number[strLen - 1]))) {
 654                         si_format = _vc_core_util_check_si_format(pinput_number);
 655                         *bsscode = TRUE;
 656                         return ERROR_VOICECALL_NONE;
 657                 }
 658         } else if (2 == strLen) {
 659 /*This will be covered, once the operator requirements are clear*/
 660 #ifdef MCC_USA_SS_CODE
 661                 unsigned long mcc = 0;
 662                 tapi_network_info_t networkInfo;
 663
 664                 memset(&networkInfo, 0x00, sizeof(tapi_network_info_t));
 665
 666                 tapi_get_network_info(&networkInfo);
 667
 668                 networkInfo.sysid.sysid = (networkInfo.sysid.sysid >> 16);
 669                 mcc = (networkInfo.sysid.sysid & 0x0000ffff);
 670                 CALL_ENG_DEBUG(ENG_DEBUG, "mcc (%d)!!", mcc);
 671
 672                 /*CALL_NETWORK_MCC_USA */
 673                 if (mcc == 0x136) {
 674                         if (strncmp(pinput_number, "08", 2) == 0 || strncmp(pinput_number, "00", 2) == 0)
 675                                 *bsscode = FALSE;
 676                 }
 677 #endif
 678                 /*08 is not a ss string.*/
 679                 if (strncmp(pinput_number, "08", 2) == 0) {
 680                         *bsscode = FALSE;
 681                 } else {
 682                         /*All two digit number should be handled as ss string during call.*/
 683                         CALL_ENG_DEBUG(ENG_DEBUG, "two digit number... returns TRUE");
 684                         *bsscode = TRUE;
 685                 }
 686
 687                 return ERROR_VOICECALL_NONE;
 688         } else if (1 == strLen) {
 689                 if (('#' == pinput_number[0]) || ('+' == pinput_number[0]) || ('*' == pinput_number[0]) || ('7' == pinput_number[0])) {
 690                         *bsscode = TRUE;
 691                         return ERROR_VOICECALL_NONE;
 692                 }
 693         }
 694
 695         CALL_ENG_DEBUG(ENG_DEBUG, "invalid sscode... returns FALSE");
 696         *bsscode = FALSE;
 697
 698         return ERROR_VOICECALL_NONE;
 699 }
 700
 701 voicecall_error_t _vc_core_engine_status_dump_call_details(voicecall_engine_t *pvoicecall_agent)
 702 {
 703         call_vc_callagent_state_t *pagent = (call_vc_callagent_state_t *)pvoicecall_agent;
 704         CALL_ENG_DEBUG(ENG_DEBUG, "");
 705         _vc_core_cm_test_dump(&pagent->call_manager);
 706         return ERROR_VOICECALL_NONE;
 707 }
 708
 709 /**
 710 * This function checks the possiblity of making private calls
 711 *
 712 * @return               ERROR_VOICECALL_NONE on success or return value contains appropriate error code on failure
 713 * @param[in]            pvoicecall_agent        Handle to Voicecall Engine
 714 * @param[out]   bzuhause                Contains TRUE if zuhause area, FALSE otherwise
 715 * @remarks              pvoicecall_agent and pbprivate_call cannot be NULL
 716 */
 717 voicecall_error_t _vc_core_engine_status_is_zuhause_area(voicecall_engine_t *pvoicecall_agent, gboolean *bzuhause)
 718 {
 719         call_vc_callagent_state_t *pcall_agent = (call_vc_callagent_state_t *)pvoicecall_agent;
 720
 721         VOICECALL_RETURN_VALUE_IF_FAIL(pcall_agent != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 722         VOICECALL_RETURN_VALUE_IF_FAIL(bzuhause != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 723
 724         *bzuhause = _vc_core_util_check_zuhause_status();
 725         return ERROR_VOICECALL_NONE;
 726 }
 727
 728 /**
 729 * This function checks the possiblity of making private calls
 730 *
 731 * @param[in]            pvoicecall_agent        Handle to Voicecall Engine
 732 * @param[out]           b_download_call         Contains TRUE if zuhause area, FALSE otherwise
 733 * @remarks                      pvoicecall_agent and pbprivate_call cannot be NULL
 734 */
 735 void _vc_core_engine_status_set_download_call(voicecall_engine_t *pvoicecall_agent, gboolean b_download_call)
 736 {
 737         call_vc_callagent_state_t *pagent = (call_vc_callagent_state_t *)pvoicecall_agent;
 738
 739         if (pagent == NULL) {
 740                 CALL_ENG_DEBUG(ENG_ERR, "pagent is NULL! [PROBLEM] !!!");
 741                 return;
 742         }
 743
 744         pagent->bdownload_call = b_download_call;
 745
 746 }
 747
 748 gboolean _vc_core_engine_status_get_download_call(voicecall_engine_t *pvoicecall_agent)
 749 {
 750         call_vc_callagent_state_t *pcall_agent = (call_vc_callagent_state_t *)pvoicecall_agent;
 751
 752         VOICECALL_RETURN_VALUE_IF_FAIL(pcall_agent != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 753
 754         return pcall_agent->bdownload_call;
 755 }