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 the possiblity of transfering calls
 379 *
 380 * @return               ERROR_VOICECALL_NONE on success or return value contains appropriate error code on failure
 381 * @param[in]            pvoicecall_agent        Handle to Voicecall Engine
 382 * @param[out]   pbtransfer_calls        Contains TRUE if call transfer is possible, FALSE otherwise
 383 * @remarks              pvoicecall_agent and pbtransfer_calls cannot be NULL
 384 */
 385 voicecall_error_t _vc_core_engine_status_is_transfer_call_possible(voicecall_engine_t *pvoicecall_agent, gboolean *pbtransfer_calls)
 386 {
 387         call_vc_callagent_state_t *pcall_agent = (call_vc_callagent_state_t *)pvoicecall_agent;
 388
 389         VOICECALL_RETURN_VALUE_IF_FAIL(pcall_agent != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 390         VOICECALL_RETURN_VALUE_IF_FAIL(pbtransfer_calls != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 391
 392         *pbtransfer_calls = _vc_core_ca_is_transfer_call_possible(pcall_agent);
 393
 394         return ERROR_VOICECALL_NONE;
 395 }
 396
 397 /**
 398 * This function checks the possiblity of making conference calls
 399 *
 400 * @return               ERROR_VOICECALL_NONE on success or return value contains appropriate error code on failure
 401 * @param[in]            pvoicecall_agent        Handle to Voicecall Engine
 402 * @param[out]   pbconf_call             Contains TRUE if conference call is possible , FALSE otherwise
 403 * @remarks              pvoicecall_agent and pbconf_call cannot be NULL
 404 */
 405 voicecall_error_t _vc_core_engine_status_is_conf_call_possible(voicecall_engine_t *pvoicecall_agent, gboolean *pbconf_call)
 406 {
 407         call_vc_callagent_state_t *pcall_agent = (call_vc_callagent_state_t *)pvoicecall_agent;
 408         gboolean active_calls = FALSE;
 409         gboolean held_calls = FALSE;
 410         int total_call_member = 0;
 411         gboolean bconf = FALSE;
 412
 413         VOICECALL_RETURN_VALUE_IF_FAIL(pcall_agent != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 414         VOICECALL_RETURN_VALUE_IF_FAIL(pbconf_call != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 415
 416 #ifdef _CPHS_DEFINED_
 417         if (_vc_core_svcall_cphs_csp_get_status(pcall_agent, VC_CPHS_CSP_MPTY)) {
 418                 CALL_ENG_DEBUG(ENG_DEBUG, "_vc_core_svcall_cphs_csp_get_status returned TRUE");
 419                 *pbconf_call = TRUE;
 420         } else {
 421                 *pbconf_call = FALSE;
 422                 return ERROR_VOICECALL_NONE;
 423         }
 424 #endif
 425
 426         _vc_core_cm_isexists_call_ingroup(&pcall_agent->call_manager, &active_calls, &held_calls);
 427         total_call_member = _vc_core_cm_get_call_member_count(&pcall_agent->call_manager);
 428
 429         /* Joining call is impossile when !active or !hold call exist */
 430         if (!active_calls || !held_calls) {
 431                 CALL_ENG_DEBUG(ENG_DEBUG, "Join Impossible...");
 432                 bconf = FALSE;
 433         } else {
 434                 /* Joining call is impossile when member is more than max
 435                 Max Number in Group + Another Call*/
 436                 if (total_call_member >= (VC_MAX_CALL_GROUP_MEMBER + 1)) {
 437                         CALL_ENG_DEBUG(ENG_DEBUG, "Ended with FALSE...");
 438                         bconf = FALSE;
 439                 } else {
 440                         CALL_ENG_DEBUG(ENG_DEBUG, "Ended with TRUE...");
 441                         bconf = TRUE;
 442                 }
 443         }
 444
 445         *pbconf_call = bconf;
 446         return ERROR_VOICECALL_NONE;
 447
 448 }
 449
 450 /**
 451 * This function retreives the call state of the given call
 452 *
 453 * @return               ERROR_VOICECALL_NONE on success or return value contains appropriate error code on failure
 454 * @param[in]    pvoicecall_agent        Handle to voicecall engine
 455 * @param[in]    call_handle             Call handle of particular call
 456 * @param[out]   pcall_state             Contains the call state of the given call handle
 457 * @remarks              pvoicecall_agent and pcall_state cannot be NULL
 458 */
 459 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)
 460 {
 461         call_vc_callagent_state_t *pagent = (call_vc_callagent_state_t *)pvoicecall_agent;
 462         call_vc_call_objectinfo_t call_object = { 0 };
 463
 464         VOICECALL_RETURN_VALUE_IF_FAIL(pagent != NULL, ERROR_VOICECALL_INVALID_CALL_HANDLE);
 465         VOICECALL_RETURN_VALUE_IF_FAIL(pcall_state != NULL, ERROR_VOICECALL_INVALID_CALL_HANDLE);
 466         VOICECALL_RETURN_VALUE_IF_FAIL(call_handle >= 0, ERROR_VOICECALL_INVALID_CALL_HANDLE);
 467
 468         _vc_core_cm_clear_call_object(&call_object);
 469         if (TRUE == _vc_core_cm_get_call_object(&pagent->call_manager, call_handle, &call_object)) {
 470                 *pcall_state = call_object.state;
 471                 return ERROR_VOICECALL_NONE;
 472         }
 473
 474         *pcall_state = VC_CALL_STATE_NONE;
 475         return ERROR_VOICECALL_CALL_INFO_NOT_AVAILABLE;
 476 }
 477
 478 #if     0       /*unused*/
 479 /**
 480 * This function retrieves call handle of the any one of the calls of given type
 481 *
 482 * @return               ERROR_VOICECALL_NONE on success or return value contains appropriate error code on failure
 483 * @param[in]    pvoicecall_agent                Handle to voicecall engine
 484 * @param[in]    connected_call_type     Connected call type
 485 * @param[out]   pcall_handle                    Contains the Call handle on return
 486 * @remarks              pvoicecall_agent and pcall_handle cannot be NULL
 487 */
 488 voicecall_error_t voicecall_get_any_call_handle(voicecall_engine_t *pvoicecall_agent, voicecall_connected_call_type_t connected_call_type, int *pcall_handle)
 489 {
 490         call_vc_callagent_state_t *pagent = (call_vc_callagent_state_t *)pvoicecall_agent;
 491         call_vc_handle callhandle = -1;
 492
 493         VOICECALL_RETURN_VALUE_IF_FAIL(pagent != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 494         VOICECALL_RETURN_VALUE_IF_FAIL(pcall_handle != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 495
 496         switch (connected_call_type) {
 497         case VC_ACTIVE_CALL:
 498                 {
 499                         _vc_core_cm_get_first_active_call_handle(&pagent->call_manager, &callhandle);
 500                 }
 501                 break;
 502         case VC_HELD_CALL:
 503                 {
 504                         _vc_core_cm_get_first_held_call_handle(&pagent->call_manager, &callhandle);
 505                 }
 506                 break;
 507         default:
 508                 return ERROR_VOICECALL_INVALID_CALL_TYPE;
 509         }
 510
 511         if (-1 != callhandle) {
 512                 *pcall_handle = (int)callhandle;
 513                 return ERROR_VOICECALL_NONE;
 514         }
 515
 516         return ERROR_VOICECALL_CALL_INFO_NOT_AVAILABLE;
 517 }
 518 #endif
 519
 520 /**
 521 * This function checks if any call is ending and retrieves its call number if it is ending
 522 *
 523 * @return               ERROR_VOICECALL_NONE on success or return value contains appropriate error code on failure
 524 * @param[in]    pvoicecall_agent        Handle to voicecall engine
 525 * @param[out]   bcall_ending            TRUE if any call is being ended, FALSE otherwise
 526 * @remarks              pvoicecall_agent and bcall_ending cannot be NULL
 527 */
 528 voicecall_error_t _vc_core_engine_status_is_any_call_ending(voicecall_engine_t *pvoicecall_agent, gboolean *bcall_ending)
 529 {
 530         call_vc_callagent_state_t *pagent = (call_vc_callagent_state_t *)pvoicecall_agent;
 531
 532         VOICECALL_RETURN_VALUE_IF_FAIL(pagent != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 533         VOICECALL_RETURN_VALUE_IF_FAIL(bcall_ending != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 534
 535         *bcall_ending = FALSE;
 536         *bcall_ending = _vc_core_cm_get_ending_call_info(&pagent->call_manager);
 537
 538         return ERROR_VOICECALL_NONE;
 539 }
 540
 541 /**
 542 * This function checks whther engine is busy in processing any events or waiting for any events to process
 543 *
 544 * @return               ERROR_VOICECALL_NONE on success or return value contains appropriate error code on failure
 545 * @param[in]    pvoicecall_agent        Handle to voicecall engine
 546 * @param[out]   bbusy   TRUE - if engine is busy in processing any events or waiting for any events, FALSE - otherwise
 547 * @remarks              pvoicecall_agent and bbusy cannot be NULL
 548 */
 549 voicecall_error_t _vc_core_engine_status_is_engine_busy(voicecall_engine_t *pvoicecall_agent, gboolean *bbusy)
 550 {
 551         call_vc_callagent_state_t *pagent = (call_vc_callagent_state_t *)pvoicecall_agent;
 552         VOICECALL_RETURN_VALUE_IF_FAIL(pagent != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 553         VOICECALL_RETURN_VALUE_IF_FAIL(bbusy != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 554
 555         CALL_ENG_DEBUG(ENG_DEBUG, "Current Call Agent State:%d", pagent->callagent_state);
 556         if (CALL_VC_CA_STATE_NORMAL == pagent->callagent_state) {
 557                 *bbusy = FALSE;
 558         } else {
 559                 *bbusy = TRUE;
 560         }
 561
 562         return ERROR_VOICECALL_NONE;
 563 }
 564
 565 /**
 566 * This function sets the given flag to engine for processing during call end.
 567 * This function has to be used after calling the end call API
 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[in]    end_flag                        End Flag to be set
 572 * @remarks              pvoicecall_agent and bsscode cannot be NULL
 573 */
 574 voicecall_error_t _vc_core_engine_status_set_end_flag(voicecall_engine_t *pvoicecall_agent, voicecall_end_flag_t end_flag)
 575 {
 576         call_vc_callagent_state_t *pagent = (call_vc_callagent_state_t *)pvoicecall_agent;
 577
 578         VOICECALL_RETURN_VALUE_IF_FAIL(pagent != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 579
 580         switch (end_flag) {
 581         case VC_RETREIVE_CALL_ON_MOCALL_END:
 582                 {
 583                         pagent->callagent_state = CALL_VC_CA_STATE_SS_WAIT_RELEASE_ALL_ACTIVECALL;
 584                 }
 585                 break;
 586         default:
 587                 return ERROR_VOICECALL_INVALID_ARGUMENTS;
 588         }
 589
 590         return ERROR_VOICECALL_NONE;
 591 }
 592
 593 /**
 594 * This function checks whether the given string is MMI string or not
 595 *
 596 * @return               ERROR_VOICECALL_NONE on success or return value contains appropriate error code on failure
 597 * @param[in]    pvoicecall_agent        Handle to voicecall engine
 598 * @param[in]    pinput_number   Input string to be verified
 599 * @param[out]   bsscode                 TRUE - if the given string is a valid ss code, FALSE otherwise
 600 * @remarks              pvoicecall_agent and bsscode cannot be NULL
 601 */
 602 voicecall_error_t _vc_core_engine_status_isvalid_ss_code(voicecall_engine_t *pvoicecall_agent, const char *pinput_number, gboolean *bsscode)
 603 {
 604         int strLen = 0;
 605         call_vc_ss_si_format si_format = SS_SI_FORMAT_INVALID;
 606
 607         VOICECALL_RETURN_VALUE_IF_FAIL(pvoicecall_agent != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 608         VOICECALL_RETURN_VALUE_IF_FAIL(pinput_number != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 609         VOICECALL_RETURN_VALUE_IF_FAIL(bsscode != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 610
 611         si_format = SS_SI_FORMAT_VALID;
 612         strLen = strlen(pinput_number);
 613
 614         CALL_ENG_DEBUG(ENG_DEBUG, "strLen = %d", strLen);
 615
 616         if (strLen > 2) {
 617                 /* Deactivate :  "#...#" */
 618                 /* Erase :               "##...#" */
 619                 if (((pinput_number[0] == '#') && (pinput_number[strLen - 1] == '#')) || ((pinput_number[0] == '+') && (pinput_number[1] == '#') && (pinput_number[strLen - 1] == '#'))) {
 620                         si_format = _vc_core_util_check_si_format(pinput_number);
 621                         *bsscode = TRUE;
 622                         return ERROR_VOICECALL_NONE;
 623                 }
 624
 625                 /* Activate :           "*...#" */
 626                 /* Interrogate :        "*#...#" */
 627                 /* Register :           "**...#" */
 628                 if ((('*' == pinput_number[0]) && ('#' == pinput_number[strLen - 1])) || (('+' == pinput_number[0]) && ('*' == pinput_number[1]) && ('#' == pinput_number[strLen - 1]))) {
 629                         si_format = _vc_core_util_check_si_format(pinput_number);
 630                         *bsscode = TRUE;
 631                         return ERROR_VOICECALL_NONE;
 632                 }
 633         } else if (2 == strLen) {
 634 /*This will be covered, once the operator requirements are clear*/
 635 #ifdef MCC_USA_SS_CODE
 636                 unsigned long mcc = 0;
 637                 tapi_network_info_t networkInfo;
 638
 639                 memset(&networkInfo, 0x00, sizeof(tapi_network_info_t));
 640
 641                 tapi_get_network_info(&networkInfo);
 642
 643                 networkInfo.sysid.sysid = (networkInfo.sysid.sysid >> 16);
 644                 mcc = (networkInfo.sysid.sysid & 0x0000ffff);
 645                 CALL_ENG_DEBUG(ENG_DEBUG, "mcc (%d)!!", mcc);
 646
 647                 /*CALL_NETWORK_MCC_USA */
 648                 if (mcc == 0x136) {
 649                         if (strncmp(pinput_number, "08", 2) == 0 || strncmp(pinput_number, "00", 2) == 0)
 650                                 *bsscode = FALSE;
 651                 }
 652 #endif
 653                 /*08 is not a ss string.*/
 654                 if (strncmp(pinput_number, "08", 2) == 0) {
 655                         *bsscode = FALSE;
 656                 } else {
 657                         /*All two digit number should be handled as ss string during call.*/
 658                         CALL_ENG_DEBUG(ENG_DEBUG, "two digit number... returns TRUE");
 659                         *bsscode = TRUE;
 660                 }
 661
 662                 return ERROR_VOICECALL_NONE;
 663         } else if (1 == strLen) {
 664                 if (('#' == pinput_number[0]) || ('+' == pinput_number[0]) || ('*' == pinput_number[0]) || ('7' == pinput_number[0])) {
 665                         *bsscode = TRUE;
 666                         return ERROR_VOICECALL_NONE;
 667                 }
 668         }
 669
 670         CALL_ENG_DEBUG(ENG_DEBUG, "invalid sscode... returns FALSE");
 671         *bsscode = FALSE;
 672
 673         return ERROR_VOICECALL_NONE;
 674 }
 675
 676 voicecall_error_t _vc_core_engine_status_dump_call_details(voicecall_engine_t *pvoicecall_agent)
 677 {
 678         call_vc_callagent_state_t *pagent = (call_vc_callagent_state_t *)pvoicecall_agent;
 679         CALL_ENG_DEBUG(ENG_DEBUG, "");
 680         _vc_core_cm_test_dump(&pagent->call_manager);
 681         return ERROR_VOICECALL_NONE;
 682 }
 683
 684 /**
 685 * This function checks the possiblity of making private calls
 686 *
 687 * @return               ERROR_VOICECALL_NONE on success or return value contains appropriate error code on failure
 688 * @param[in]            pvoicecall_agent        Handle to Voicecall Engine
 689 * @param[out]   bzuhause                Contains TRUE if zuhause area, FALSE otherwise
 690 * @remarks              pvoicecall_agent and pbprivate_call cannot be NULL
 691 */
 692 voicecall_error_t _vc_core_engine_status_is_zuhause_area(voicecall_engine_t *pvoicecall_agent, gboolean *bzuhause)
 693 {
 694         call_vc_callagent_state_t *pcall_agent = (call_vc_callagent_state_t *)pvoicecall_agent;
 695
 696         VOICECALL_RETURN_VALUE_IF_FAIL(pcall_agent != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 697         VOICECALL_RETURN_VALUE_IF_FAIL(bzuhause != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 698
 699         *bzuhause = _vc_core_util_check_zuhause_status();
 700         return ERROR_VOICECALL_NONE;
 701 }
 702
 703 /**
 704 * This function checks the possiblity of making private calls
 705 *
 706 * @param[in]            pvoicecall_agent        Handle to Voicecall Engine
 707 * @param[out]           b_download_call         Contains TRUE if zuhause area, FALSE otherwise
 708 * @remarks                      pvoicecall_agent and pbprivate_call cannot be NULL
 709 */
 710 void _vc_core_engine_status_set_download_call(voicecall_engine_t *pvoicecall_agent, gboolean b_download_call)
 711 {
 712         call_vc_callagent_state_t *pagent = (call_vc_callagent_state_t *)pvoicecall_agent;
 713
 714         if (pagent == NULL) {
 715                 CALL_ENG_DEBUG(ENG_ERR, "pagent is NULL! [PROBLEM] !!!");
 716                 return;
 717         }
 718
 719         pagent->bdownload_call = b_download_call;
 720
 721 }
 722
 723 gboolean _vc_core_engine_status_get_download_call(voicecall_engine_t *pvoicecall_agent)
 724 {
 725         call_vc_callagent_state_t *pcall_agent = (call_vc_callagent_state_t *)pvoicecall_agent;
 726
 727         VOICECALL_RETURN_VALUE_IF_FAIL(pcall_agent != NULL, ERROR_VOICECALL_INVALID_ARGUMENTS);
 728
 729         return pcall_agent->bdownload_call;
 730 }