开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > MTK > 查看源码
OutgoingCallManagement.c
资源名称：mmi.rar　[点击查看]
上传用户：lqx1163
上传日期：2014-08-13
资源大小：9183k
文件大小：201k
源码类别：

MTK

开发平台：

C/C++

OutgoingCallManagement.c：源码内容
  1. /*****************************************************************************
  2. *  Copyright Statement:
  3. *  --------------------
  4. *  This software is protected by Copyright and the information contained
  5. *  herein is confidential. The software may not be copied and the information
  6. *  contained herein may not be used or disclosed except with the written
  7. *  permission of MediaTek Inc. (C) 2005
  8. *
  9. *  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  10. *  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  11. *  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
  12. *  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
  13. *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
  14. *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
  15. *  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
  16. *  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
  17. *  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
  18. *  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
  19. *  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
  20. *  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
  21. *
  22. *  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
  23. *  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
  24. *  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
  25. *  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
  26. *  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. 
  27. *
  28. *  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
  29. *  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
  30. *  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
  31. *  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
  32. *  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
  33. *
  34. *****************************************************************************/
  35. /*******************************************************************************
  36.  *  Modification Notice:
  37.  *  --------------------------
  38.  *  This software is modified by MediaTek Inc. and the information contained
  39.  *  herein is confidential. The software may not be copied and the information
  40.  *  contained herein may not be used or disclosed except with the written
  41.  *  permission of MediaTek Inc. (C) 2001
  42.  *
  43.  *******************************************************************************/
  45.  /*******************************************************************************
  46.  * Filename:
  47.  * ---------
  48.  *   OutgoingCallmanagement.c
  49.  *
  50.  * Project:
  51.  * --------
  52.  *   Maui_Software
  53.  *
  54.  * Description:
  55.  * ------------
  56.  *  .......
  57.  *
  58.  * Author:
  59.  * -------
  60.  * -------
  61.  *
  62.  *------------------------------------------------------------------------------
  63.  * $Log$
  64.  *
  65.  * removed!
  66.  * removed!
  67.  * 
  68.  *
  69.  * removed!
  70.  * removed!
  71.  * 
  72.  *
  73.  * removed!
  74.  * removed!
  75.  * 
  76.  *
  77.  * removed!
  78.  * removed!
  79.  * 
  80.  *
  81.  * removed!
  82.  * removed!
  83.  * 
  84.  *
  85.  * removed!
  86.  * removed!
  87.  * 
  88.  *
  89.  * removed!
  90.  * removed!
  91.  * 
  92.  *
  93.  * removed!
  94.  * removed!
  95.  * 
  96.  *
  97.  * removed!
  98.  * removed!
  99.  * 
  100.  *
  101.  * removed!
  102.  * removed!
  103.  * 
  104.  *
  105.  * removed!
  106.  * removed!
  107.  * 
  108.  *
  109.  * removed!
  110.  * removed!
  111.  * 
  112.  *
  113.  * removed!
  114.  * removed!
  115.  * 
  116.  *
  117.  * removed!
  118.  * removed!
  119.  * 
  120.  *
  121.  * removed!
  122.  * removed!
  123.  * 
  124.  *
  125.  * removed!
  126.  * removed!
  127.  * 
  128.  *
  129.  * removed!
  130.  * removed!
  131.  * 
  132.  *
  133.  * removed!
  134.  * removed!
  135.  * 
  136.  *
  137.  * removed!
  138.  * removed!
  139.  * 
  140.  *
  141.  * removed!
  142.  * removed!
  143.  * 
  144.  *
  145.  * removed!
  146.  * removed!
  147.  * 
  148.  *
  149.  * removed!
  150.  * removed!
  151.  * 
  152.  *
  153.  * removed!
  154.  * removed!
  155.  * 
  156.  *
  157.  * removed!
  158.  * removed!
  159.  * 
  160.  *
  161.  * removed!
  162.  * removed!
  163.  * 
  164.  *
  165.  * removed!
  166.  * removed!
  167.  * 
  168.  *
  169.  * removed!
  170.  * removed!
  171.  * 
  172.  *
  173.  * removed!
  174.  * removed!
  175.  * 
  176.  *
  177.  * removed!
  178.  * removed!
  179.  * 
  180.  *
  181.  * removed!
  182.  * removed!
  183.  * 
  184.  *
  185.  * removed!
  186.  * removed!
  187.  * 
  188.  *
  189.  * removed!
  190.  * removed!
  191.  * 
  192.  *
  193.  * removed!
  194.  * removed!
  195.  * 
  196.  *
  197.  * removed!
  198.  * removed!
  199.  * 
  200.  *
  201.  * removed!
  202.  * removed!
  203.  * 
  204.  *
  205.  * removed!
  206.  * removed!
  207.  * 
  208.  *
  209.  * removed!
  210.  * removed!
  211.  * 
  212.  *
  213.  * removed!
  214.  * removed!
  215.  * 
  216.  *
  217.  * removed!
  218.  * removed!
  219.  * 
  220.  *
  221.  * removed!
  222.  * removed!
  223.  * 
  224.  *
  225.  * removed!
  226.  * removed!
  227.  * 
  228.  *
  229.  * removed!
  230.  * removed!
  231.  * 
  232.  *
  233.  * removed!
  234.  * removed!
  235.  * 
  236.  *
  237.  * removed!
  238.  * removed!
  239.  * 
  240.  *
  241.  * removed!
  242.  * removed!
  243.  * 
  244.  *
  245.  * removed!
  246.  * removed!
  247.  * 
  248.  *
  249.  * removed!
  250.  * removed!
  251.  * 
  252.  *
  253.  * removed!
  254.  * removed!
  255.  * 
  256.  *
  257.  * removed!
  258.  * removed!
  259.  * 
  260.  *
  261.  * removed!
  262.  * removed!
  263.  * 
  264.  *
  265.  * removed!
  266.  * removed!
  267.  * 
  268.  *
  269.  * removed!
  270.  * removed!
  271.  * 
  272.  *
  273.  * removed!
  274.  * removed!
  275.  * 
  276.  *
  277.  * removed!
  278.  * removed!
  279.  * 
  280.  *
  281.  * removed!
  282.  * removed!
  283.  * 
  284.  *
  285.  * removed!
  286.  * removed!
  287.  * 
  288.  *
  289.  * removed!
  290.  * removed!
  291.  * 
  292.  *
  293.  * removed!
  294.  * removed!
  295.  * 
  296.  *
  297.  * removed!
  298.  * removed!
  299.  * 
  300.  *
  301.  * removed!
  302.  * removed!
  303.  * 
  304.  *
  305.  * removed!
  306.  * removed!
  307.  * 
  308.  *
  309.  * removed!
  310.  * removed!
  311.  * 
  312.  *
  313.  * removed!
  314.  * removed!
  315.  * 
  316.  *
  317.  * removed!
  318.  * removed!
  319.  * 
  320.  *
  321.  * removed!
  322.  * removed!
  323.  * 
  324.  *
  325.  * removed!
  326.  * removed!
  327.  * 
  328.  *
  329.  * removed!
  330.  * removed!
  331.  * 
  332.  *
  333.  * removed!
  334.  * removed!
  335.  * 
  336.  *
  337.  * removed!
  338.  * removed!
  339.  * 
  340.  *
  341.  * removed!
  342.  * removed!
  343.  * 
  344.  *
  345.  * removed!
  346.  * removed!
  347.  * 
  348.  *
  349.  * removed!
  350.  * removed!
  351.  * 
  352.  *
  353.  * removed!
  354.  * removed!
  355.  * 
  356.  *
  357.  * removed!
  358.  * removed!
  359.  * 
  360.  *
  361.  * removed!
  362.  * removed!
  363.  * Apply new bootup revise APIs
  364.  *
  365.  * removed!
  366.  * removed!
  367.  * 
  368.  *
  369.  * removed!
  370.  * removed!
  371.  * 
  372.  *
  373.  * removed!
  374.  * removed!
  375.  * 
  376.  *
  377.  * removed!
  378.  * removed!
  379.  * 
  380.  *
  381.  * removed!
  382.  * removed!
  383.  * 
  384.  *
  385.  * removed!
  386.  * removed!
  387.  * 
  388.  *
  389.  * removed!
  390.  * removed!
  391.  * 
  392.  *
  393.  * removed!
  394.  * removed!
  395.  * 
  396.  *
  397.  * removed!
  398.  * removed!
  399.  * 
  400.  *
  401.  * removed!
  402.  * removed!
  403.  * 
  404.  *
  405.  *******************************************************************************/
  407. /**
  408.  * Copyright Notice
  409.  * ?2002 - 2003, Pixtel Communications, Inc., 1489 43rd Ave. W.,
  410.  * Vancouver, B.C. V6M 4K8 Canada. All Rights Reserved.
  411.  *  (It is illegal to remove this copyright notice from this software or any
  412.  *  portion of it)
  413.  */
  415. /**************************************************************
  417.    FILENAME : OutgoingCallmanagement.c
  419.    PURPOSE     : Call Management application
  421.    REMARKS     : nil
  423.    AUTHOR      : Subramanya BG
  425.    DATE     : Nov 11,02
  427. **************************************************************/
  428. #include "stdC.h"
  429. #include "MMI_Features.h"
  430. #include "L4Dr.h"
  431. #include "L4Dr1.h"
  432. #include "PixtelDataTypes.h"
  433. #include "DebugInitDef.h"
  434. #include "ProtocolEvents.h"
  435. #include "EventsGprot.h"
  436. #include "HistoryGprot.h"
  437. #include "SubLCDHistoryGprot.h"
  438. #include "GlobalDefs.h"
  439. #include "GlobalScrEnum.h"
  440. #include "KeyBrd.h"
  441. #include "TimerEvents.h"
  442. #include "CommonScreens.h"
  443. #include "wgui.h"
  444. #include "Wgui_categories_popup.h"
  445. #include "wgui_categories_CM.h"
  447. #include "DateTimeGprot.h"
  448. /* micha0521 */
  449. #include "SATDefs.h"
  450. #include "SATGProts.h"
  451. #include "SimDetectionGexdcl.h"
  452. #include "gpioInc.h"
  453. #include "CSP.h"
  454. #include "CallSetUp.h"
  455. #include "ProfileGprots.h"
  456. #include "ManageCallMain.h"
  457. #include "PhoneBookDef.h"
  458. #include "PhoneBookGprot.h"
  459. #include "MessagesExDcl.h"
  460. #include "MessagesResourceData.h"
  461. #include "SMSApi.h"
  462. #include "AlarmFrameworkProt.h"
  464. #include "mdi_datatype.h"
  465. #include "mdi_audio.h"
  466. #ifdef __MMI_VOICE_MEMO__
  467. #include "VoiceMemoProt.h"
  468. #endif 
  469. #ifdef __MMI_SOUND_RECORDER__
  470. #include "SoundRecorderProt.h"
  471. #endif 
  472. #ifdef __MMI_AUDIO_PLAYER__
  473. #include "AudioPlayerProt.h"
  474. #endif 
  476. #ifdef __MMI_BT_HP_SUPPORT__
  477. #include "BTMMIHPGprots.h"
  478. #endif 
  480. #ifdef __MMI_BT_SUPPORT__
  481. #include "BTMMIScrGprots.h"
  482. #endif 
  484. #ifdef __CTM_SUPPORT__
  485. #include "TextPhoneDef.h"
  486. #include "TextPhoneProt.h"
  487. #endif /* __CTM_SUPPORT__ */ 
  488. #ifdef __MMI_VOIP__
  489. #include "VoIPGProt.h"
  490. #endif
  491. #include "CallManagementIdDef.h"
  492. #include "CallManagementStruct.h"
  493. #include "CallStructureManagementProt.h"
  494. #include "CmErrorTypes.h"
  495. #include "CmErrorHandlersProt.h"
  496. #include "HistoryHelperProt.h"
  497. #include "CommonStubsProt.h"
  498. #include "PsCallHelperDef.h"
  499. #include "mmiapi_struct.h"
  500. #include "PsCallHelperGprot.h"
  501. #include "RedialHelperGProt.h"
  502. #include "CallManagementGprot.h"
  503. #include "IncomingCallManagementProt.h"
  504. #include "OutgoingCallHelperProt.h"
  506. #include "OutgoingCallManagementProt.h"
  508. /* micha1115 */
  509. #include "CallSetUpEnum.h"
  510. #include "SimDetectionGprot.h"
  513. #define TEMP_NO 10
  514. #define SCR_TEXT_LEN 50
  516. static OUTGOING_CALL gCurrOutcall;  /* This is a global variable usefull till the */
  517. static PU8 gcallList[MAX_CALLS];
  518. static U16 gcallListImage[MAX_CALLS];
  519. static U16 gcallListlen = 0;
  520. static U16 gHilitedCall = 0;
  521. static U8 gListOperation = 0;
  523. U16 gtmpOutgoingIndex;
  525. extern MYTIME gTimeStructForCallDuration;
  526. extern const U16 CMIdleScreenDigits[];
  527. extern S8 DTMFPadCallBuffer[MAX_DIGITS_USSD];
  528. extern PU8 gdispnameForSubLCD;
  530. extern void MMIProcessActionMsg(void);
  532. #if defined(__MMI_PHB_CALL_SHOW_PICTURE_FROM_FILE__)
  533. extern S8 *mmi_phb_image_get_path_from_id(U16 index);
  534. #endif 
  537. /*****************************************************************************
  538.  * FUNCTION
  539.  *  ReinitializeOutgoingCall
  540.  * DESCRIPTION
  541.  *  To ReInitialize the Outgoing Call Management Application
  542.  * PARAMETERS
  543.  *  void
  544.  * RETURNS
  545.  *  void
  546.  *****************************************************************************/
  547. void ReinitializeOutgoingCall(void)
  548. {
  549.     /*----------------------------------------------------------------*/
  550.     /* Local Variables                                                */
  551.     /*----------------------------------------------------------------*/
  553.     /*----------------------------------------------------------------*/
  554.     /* Code Body                                                      */
  555.     /*----------------------------------------------------------------*/
  556.     SetDialIndication(FALSE);
  557. #ifdef __IP_NUMBER__
  558.     SetTempUseIPNumber(FALSE);
  559. #endif 
  561.     SetProtocolEventHandler(PsCBackPlayInternalTone, PRT_PLAY_GSM_TONE);
  562.     SetProtocolEventHandler(OutgoingCallConnected, PRT_OUTGOINGCALL_CONNECTED);
  563.     SetProtocolEventHandler(PsCbackOutgoingCallIdSync, PRT_OUTGOINGCALL_EVENT_RSP);
  564.     SetProtocolEventHandler(PsCBackUSSDResponse, PRT_USSD_RES_SUCCESS);
  565.     #ifdef MMI_ON_HARDWARE_P
  566.     SetProtocolEventHandler(MakeCallReqInd, PRT_MMI_MAKE_CALL_REQ_IND);
  567. #endif /* MMI_ON_HARDWARE_P */
  568. }
  571. /*****************************************************************************
  572.  * FUNCTION
  573.  *  InitOutGoingCall
  574.  * DESCRIPTION
  575.  *  To Initialize the Outgoing Call Management Application
  576.  *  
  577.  *  This function sets up the handlers required for event flow and
  578.  *  application management.This function is invoked from InitIncomingCall.
  579.  * PARAMETERS
  580.  *  void
  581.  * RETURNS
  582.  *  void
  583.  *****************************************************************************/
  584. void InitOutGoingCall(void)
  585. {
  586.     /*----------------------------------------------------------------*/
  587.     /* Local Variables                                                */
  588.     /*----------------------------------------------------------------*/
  590.     /*----------------------------------------------------------------*/
  591.     /* Code Body                                                      */
  592.     /*----------------------------------------------------------------*/
  593.     ReinitializeOutgoingCall();
  595.     SetHiliteHandler(MITEM2011_CM_S_ACTIVE_END, HiliteM2019AllActiveEnd);
  596.     SetHiliteHandler(MITEM2011_CM_END_SINGLE, HiliteM2011EndSingle);
  597.     SetHiliteHandler(MITEM2011_CM_INC_END_SINGLE, HiliteM2011IncEndSingle);
  598.     SetHiliteHandler(MITEM2019_CM_ALL_ACTIVE_END, HiliteM2019AllActiveEnd);
  599.     SetHiliteHandler(MITEM2020_CM_ALL_HELD_END, HiliteM2020AllHeldEnd);
  600.     SetHiliteHandler(MITEM2050_CM_END_HELD_ENDALL_HELD, HiliteM2020AllHeldEnd);
  601.     SetHiliteHandler(MITEM2011_CM_END, HiliteM2016AllCallEnd);
  602.     SetHiliteHandler(MITEM2011_CM_END_ALL, HiliteM2016AllCallEnd);
  603.     SetHiliteHandler(MITEM2016_CM_ALL_CALL_END, HiliteM2016AllCallEnd);
  604.     SetHiliteHandler(MITEM_OUTGOING_REJECT, HiliteIncomingReject);
  606.     SetHiliteHandler(MITEM2010_CM_ACTIVE_HOLD, HiliteM2010ActiveHold);
  607.     SetHiliteHandler(MITEM2010_CM_M_ACTIVE_HOLD, HiliteM2010ActiveHold);
  608.     SetHiliteHandler(MITEM2012_CM_HELD_RETRIEVE, HiliteM2012HeldRetrieve);
  609.     SetHiliteHandler(MITEM2012_CM_M_HELD_RETRIEVE, HiliteM2012HeldRetrieve);
  610.     SetHiliteHandler(MITEM2014_CM_CALL_SWAP, HiliteM2014Swap);
  611.     SetHiliteHandler(MITEM2015_CM_CALL_CONFER, HiliteM2015Conference);
  612.     SetHiliteHandler(MITEM2017_CM_CALL_TRANSFER, HiliteM2017Transfer);
  613.     SetHiliteHandler(MITEM2018_CM_CALL_SPLIT, HiliteM2018Split);
  615.     SetHiliteHandler(MITEM2031_CM_PBOOK, HiliteM2031PBookAppEntry);
  616.     SetHiliteHandler(MITEM2032_CM_SMS, HiliteM2032MsgAppEntry);
  617. #ifdef __MMI_VOICE_MEMO__
  618.     SetHiliteHandler(MITEM2022_CM_VOICE_MEMO, HiliteM2022VoiceMemo);
  619. #endif 
  620. #ifdef __MMI_SOUND_RECORDER__
  621.     SetHiliteHandler(MITEM2026_CM_SOUND_RECORDER, HiliteM2026SoundRecorder);
  622. #endif 
  623. #ifdef __MMI_AUDIO_PLAYER__
  624.     SetHiliteHandler(MITEM2025_CM_AUDIO_PLAYER, HiliteM2025AudioPlayer);
  625. #endif 
  627. #if defined(__MMI_BT_HP_SUPPORT__) || defined(__MMI_BT_SUPPORT__)
  628.     SetHiliteHandler(MITEM_CM_BT_SETPATH, HiliteBTCMSetPath);
  629. #endif 
  631.     SetHiliteHandler(MITEM2020_CM_MUTE, HiliteM2020Mute);
  632.     SetHiliteHandler(MITEM2024_CM_DTMF, HiliteM2024DTMF);
  633.     SetHiliteHandler(MITEM2021_CM_NEWCALL, HiliteM2021NewCall);
  634. #ifdef __CTM_SUPPORT__
  635.     SetHiliteHandler(MITEM2027_CM_CTM, HiliteM2027CTM);
  636. #endif 
  638.     SetHintHandler(MITEM2020_CM_MUTE, Hint2020Mute);
  639.     SetHintHandler(MITEM2024_CM_DTMF, Hint2024DTMF);
  640. }
  643. /*****************************************************************************
  644.  * FUNCTION
  645.  *  HiliteM2011EndSingle
  646.  * DESCRIPTION
  647.  *  hilite handler to invoke End Single function call
  648.  * PARAMETERS
  649.  *  void
  650.  * RETURNS
  651.  *  void
  652.  *****************************************************************************/
  653. void HiliteM2011EndSingle(void)
  654. {
  655.     /*----------------------------------------------------------------*/
  656.     /* Local Variables                                                */
  657.     /*----------------------------------------------------------------*/
  659.     /*----------------------------------------------------------------*/
  660.     /* Code Body                                                      */
  661.     /*----------------------------------------------------------------*/
  662.     PRINT_INFORMATION(("n 2011 End Single n"));
  664.     ClearKeyHandler(KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  665.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_SCR1003_LSK);
  666. #ifdef __GPRS_MODE__
  667.     SetLeftSoftkeyFunction(HangupHilited, KEY_EVENT_UP);
  668. #else 
  669.     SetLeftSoftkeyFunction(EndSingleAndGoBack, KEY_EVENT_UP);
  670. #endif 
  671.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  672. }
  675. /*****************************************************************************
  676.  * FUNCTION
  677.  *  HiliteM2011IncEndSingle
  678.  * DESCRIPTION
  679.  *  hilite handler to invoke End Single function call
  680.  *  when MT call present
  681.  * PARAMETERS
  682.  *  void
  683.  * RETURNS
  684.  *  void
  685.  *****************************************************************************/
  686. void HiliteM2011IncEndSingle(void)
  687. {
  688.     /*----------------------------------------------------------------*/
  689.     /* Local Variables                                                */
  690.     /*----------------------------------------------------------------*/
  692.     /*----------------------------------------------------------------*/
  693.     /* Code Body                                                      */
  694.     /*----------------------------------------------------------------*/
  695.     PRINT_INFORMATION(("n 2011 End Single n"));
  697.     ClearKeyHandler(KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  698.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_SCR1003_LSK);
  699.     SetLeftSoftkeyFunction(EndSingleAndGoBack, KEY_EVENT_UP);
  700.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  701. }
  704. /*****************************************************************************
  705.  * FUNCTION
  706.  *  HiliteM2011SingleActiveEnd
  707.  * DESCRIPTION
  708.  *  Hilite function for selecting active call to end
  709.  *  
  710.  *  In case there is only one active call the incoming call must be accepted
  711.  *  otherwise a screen to select an active call to end must be Shown
  712.  * PARAMETERS
  713.  *  void
  714.  * RETURNS
  715.  *  void
  716.  *****************************************************************************/
  717. void HiliteM2011SingleActiveEnd(void)
  718. {
  719.     /*----------------------------------------------------------------*/
  720.     /* Local Variables                                                */
  721.     /*----------------------------------------------------------------*/
  723.     /*----------------------------------------------------------------*/
  724.     /* Code Body                                                      */
  725.     /*----------------------------------------------------------------*/
  726.     ClearKeyHandler(KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  727.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_GLOBAL_OK);
  728.     SetLeftSoftkeyFunction(EndSingleActiveAndGoBack, KEY_EVENT_UP);
  729.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  730. }
  733. /*****************************************************************************
  734.  * FUNCTION
  735.  *  HiliteM2019AllActiveEnd
  736.  * DESCRIPTION
  737.  *  hilite handler to invoke function that hangup all the active call
  738.  * PARAMETERS
  739.  *  void
  740.  * RETURNS
  741.  *  void
  742.  *****************************************************************************/
  743. void HiliteM2019AllActiveEnd(void)
  744. {
  745.     /*----------------------------------------------------------------*/
  746.     /* Local Variables                                                */
  747.     /*----------------------------------------------------------------*/
  749.     /*----------------------------------------------------------------*/
  750.     /* Code Body                                                      */
  751.     /*----------------------------------------------------------------*/
  752.     PRINT_INFORMATION(("n 2019 AllActiveEnd n"));
  754.     ClearKeyHandler(KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  755.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_SCR1003_LSK);
  756.     SetLeftSoftkeyFunction(HangupallActive, KEY_EVENT_UP);
  757.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  758. }
  761. /*****************************************************************************
  762.  * FUNCTION
  763.  *  HiliteM2020AllHeldEnd
  764.  * DESCRIPTION
  765.  *  hilite handler to invoke the function that hangup all the heldcall
  766.  * PARAMETERS
  767.  *  void
  768.  * RETURNS
  769.  *  void
  770.  *****************************************************************************/
  771. void HiliteM2020AllHeldEnd(void)
  772. {
  773.     /*----------------------------------------------------------------*/
  774.     /* Local Variables                                                */
  775.     /*----------------------------------------------------------------*/
  777.     /*----------------------------------------------------------------*/
  778.     /* Code Body                                                      */
  779.     /*----------------------------------------------------------------*/
  780.     PRINT_INFORMATION(("n 2020 AllHeldEnd n"));
  782.     ClearKeyHandler(KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  783.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_SCR1003_LSK);
  784.     SetLeftSoftkeyFunction(HangupallHeld, KEY_EVENT_UP);
  785.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  786. }
  789. /*****************************************************************************
  790.  * FUNCTION
  791.  *  HiliteM2016AllCallEnd
  792.  * DESCRIPTION
  793.  *  hilite handler to invoke the hangup of all the calls
  794.  * PARAMETERS
  795.  *  void
  796.  * RETURNS
  797.  *  void
  798.  *****************************************************************************/
  799. void HiliteM2016AllCallEnd(void)
  800. {
  801.     /*----------------------------------------------------------------*/
  802.     /* Local Variables                                                */
  803.     /*----------------------------------------------------------------*/
  805.     /*----------------------------------------------------------------*/
  806.     /* Code Body                                                      */
  807.     /*----------------------------------------------------------------*/
  808.     PRINT_INFORMATION(("n 2016 AllCallEnd n"));
  810.     ClearKeyHandler(KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  811.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_SCR1003_LSK);
  812.     SetLeftSoftkeyFunction(KbCBackEndAllCallsExceptIncoming, KEY_EVENT_UP);
  813.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  814. }
  817. /*****************************************************************************
  818.  * FUNCTION
  819.  *  HiliteIncomingReject
  820.  * DESCRIPTION
  821.  *  hilite handler to incoming reject call
  822.  * PARAMETERS
  823.  *  void
  824.  * RETURNS
  825.  *  void
  826.  *****************************************************************************/
  827. void HiliteIncomingReject(void)
  828. {
  829.     /*----------------------------------------------------------------*/
  830.     /* Local Variables                                                */
  831.     /*----------------------------------------------------------------*/
  833.     /*----------------------------------------------------------------*/
  834.     /* Code Body                                                      */
  835.     /*----------------------------------------------------------------*/
  836.     PRINT_INFORMATION(("n HiliteIncomingRejectn"));
  838.     ClearKeyHandler(KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  839.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_SCR1003_LSK);
  840.     SetLeftSoftkeyFunction(KbCBackCallIncomingRejected, KEY_EVENT_UP);
  841.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  842. }
  845. /*****************************************************************************
  846.  * FUNCTION
  847.  *  HiliteM2010ActiveHold
  848.  * DESCRIPTION
  849.  *  hilite handler to invoke the hold function call
  850.  * PARAMETERS
  851.  *  void
  852.  * RETURNS
  853.  *  void
  854.  *****************************************************************************/
  855. void HiliteM2010ActiveHold(void)
  856. {
  857.     /*----------------------------------------------------------------*/
  858.     /* Local Variables                                                */
  859.     /*----------------------------------------------------------------*/
  861.     /*----------------------------------------------------------------*/
  862.     /* Code Body                                                      */
  863.     /*----------------------------------------------------------------*/
  864.     PRINT_INFORMATION(("n 2010 ActiveHoldn"));
  866.     ClearKeyHandler(KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  867.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_SCR1003_LSK);
  868.     SetLeftSoftkeyFunction(MakeActiveCallHold, KEY_EVENT_UP);
  869.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  870. }
  873. /*****************************************************************************
  874.  * FUNCTION
  875.  *  HiliteM2012HeldRetrieve
  876.  * DESCRIPTION
  877.  *  hilite handler to invoke the Retrieve function call
  878.  * PARAMETERS
  879.  *  void
  880.  * RETURNS
  881.  *  void
  882.  *****************************************************************************/
  883. void HiliteM2012HeldRetrieve(void)
  884. {
  885.     /*----------------------------------------------------------------*/
  886.     /* Local Variables                                                */
  887.     /*----------------------------------------------------------------*/
  889.     /*----------------------------------------------------------------*/
  890.     /* Code Body                                                      */
  891.     /*----------------------------------------------------------------*/
  892.     PRINT_INFORMATION(("n 2012 HeldRetrieve n"));
  894.     ClearKeyHandler(KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  895.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_SCR1003_LSK);
  896.     SetLeftSoftkeyFunction(RetrieveHeldCall, KEY_EVENT_UP);
  897.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  898. }
  901. /*****************************************************************************
  902.  * FUNCTION
  903.  *  HiliteM2014Swap
  904.  * DESCRIPTION
  905.  *  hilite handler to invoke the Swap function call
  906.  * PARAMETERS
  907.  *  void
  908.  * RETURNS
  909.  *  void
  910.  *****************************************************************************/
  911. void HiliteM2014Swap(void)
  912. {
  913.     /*----------------------------------------------------------------*/
  914.     /* Local Variables                                                */
  915.     /*----------------------------------------------------------------*/
  917.     /*----------------------------------------------------------------*/
  918.     /* Code Body                                                      */
  919.     /*----------------------------------------------------------------*/
  920.     PRINT_INFORMATION(("n 2014 Swap n"));
  922.     ClearKeyHandler(KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  923.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_SCR1003_LSK);
  924.     SetLeftSoftkeyFunction(SwapCall, KEY_EVENT_UP);
  925.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  926. }
  929. /*****************************************************************************
  930.  * FUNCTION
  931.  *  HiliteM2015Conference
  932.  * DESCRIPTION
  933.  *  hilite handler to invoke the Conference function call
  934.  * PARAMETERS
  935.  *  void
  936.  * RETURNS
  937.  *  void
  938.  *****************************************************************************/
  939. void HiliteM2015Conference(void)
  940. {
  941.     /*----------------------------------------------------------------*/
  942.     /* Local Variables                                                */
  943.     /*----------------------------------------------------------------*/
  945.     /*----------------------------------------------------------------*/
  946.     /* Code Body                                                      */
  947.     /*----------------------------------------------------------------*/
  948.     PRINT_INFORMATION(("n 2015 Conference n"));
  950.     ClearKeyHandler(KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  951.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_SCR1003_LSK);
  952.     SetLeftSoftkeyFunction(ConferenceCall, KEY_EVENT_UP);
  953.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  954. }
  957. /*****************************************************************************
  958.  * FUNCTION
  959.  *  HiliteM2017Transfer
  960.  * DESCRIPTION
  961.  *  hilite handler to invoke the function that transfer the call
  962.  *  
  963.  *  yet to  implement
  964.  * PARAMETERS
  965.  *  void
  966.  * RETURNS
  967.  *  void
  968.  *****************************************************************************/
  969. void HiliteM2017Transfer(void)
  970. {
  971.     /*----------------------------------------------------------------*/
  972.     /* Local Variables                                                */
  973.     /*----------------------------------------------------------------*/
  975.     /*----------------------------------------------------------------*/
  976.     /* Code Body                                                      */
  977.     /*----------------------------------------------------------------*/
  978.     PRINT_INFORMATION(("n 2017 Transfer n"));
  980.     ClearKeyHandler(KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  981.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_SCR1003_LSK);
  982.     SetLeftSoftkeyFunction(TransferCall, KEY_EVENT_UP);
  983.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  984. }
  987. /*****************************************************************************
  988.  * FUNCTION
  989.  *  HiliteM2018Split
  990.  * DESCRIPTION
  991.  *  hilite handler to invoke the Split function call
  992.  * PARAMETERS
  993.  *  void
  994.  * RETURNS
  995.  *  void
  996.  *****************************************************************************/
  997. void HiliteM2018Split(void)
  998. {
  999.     /*----------------------------------------------------------------*/
  1000.     /* Local Variables                                                */
  1001.     /*----------------------------------------------------------------*/
  1003.     /*----------------------------------------------------------------*/
  1004.     /* Code Body                                                      */
  1005.     /*----------------------------------------------------------------*/
  1006.     PRINT_INFORMATION(("n 2018 Split n"));
  1008.     ClearKeyHandler(KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  1009.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_SCR1003_LSK);
  1010. #ifdef __GPRS_MODE__
  1011.     SetLeftSoftkeyFunction(SplitHilited, KEY_EVENT_UP);
  1012. #else 
  1013.     SetLeftSoftkeyFunction(SplitAndGoBack, KEY_EVENT_UP);
  1014. #endif 
  1015.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  1016. }
  1019. /*****************************************************************************
  1020.  * FUNCTION
  1021.  *  DummyEnterPhbFrmActiveCall
  1022.  * DESCRIPTION
  1023.  *  set CM screen flag before go to PHB application
  1024.  * PARAMETERS
  1025.  *  void
  1026.  * RETURNS
  1027.  *  void
  1028.  *****************************************************************************/
  1029. void DummyEnterPhbFrmActiveCall(void)
  1030. {
  1031.     /*----------------------------------------------------------------*/
  1032.     /* Local Variables                                                */
  1033.     /*----------------------------------------------------------------*/
  1035.     /*----------------------------------------------------------------*/
  1036.     /* Code Body                                                      */
  1037.     /*----------------------------------------------------------------*/
  1038.     SetCMScrnFlag(FALSE);
  1039.     mmi_phb_call_enter_from_active_call();
  1040.     DeleteScreenIfPresent(SCR1003_CM_ACTIVECALLOPTIONS);    
  1041. }
  1044. /*****************************************************************************
  1045.  * FUNCTION
  1046.  *  HiliteM2031PBookAppEntry
  1047.  * DESCRIPTION
  1048.  *  hilite handler to invoke the Pbook app entry
  1049.  * PARAMETERS
  1050.  *  void
  1051.  * RETURNS
  1052.  *  void
  1053.  *****************************************************************************/
  1054. void HiliteM2031PBookAppEntry(void)
  1055. {
  1056.     /*----------------------------------------------------------------*/
  1057.     /* Local Variables                                                */
  1058.     /*----------------------------------------------------------------*/
  1060.     /*----------------------------------------------------------------*/
  1061.     /* Code Body                                                      */
  1062.     /*----------------------------------------------------------------*/
  1063.     PRINT_INFORMATION(("n 2031 PBookAppEntry n"));
  1065.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_SCR1003_LSK);
  1066.     SetKeyHandler(DummyEnterPhbFrmActiveCall, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  1067.     SetLeftSoftkeyFunction(DummyEnterPhbFrmActiveCall, KEY_EVENT_UP);
  1068.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  1069. }
  1072. /*****************************************************************************
  1073.  * FUNCTION
  1074.  *  DummyPreEntryScrMessagesMenuList
  1075.  * DESCRIPTION
  1076.  *  set CM screen flag before go to SMS application
  1077.  * PARAMETERS
  1078.  *  void
  1079.  * RETURNS
  1080.  *  void
  1081.  *****************************************************************************/
  1082. void DummyPreEntryScrMessagesMenuList(void)
  1083. {
  1084.     /*----------------------------------------------------------------*/
  1085.     /* Local Variables                                                */
  1086.     /*----------------------------------------------------------------*/
  1088.     /*----------------------------------------------------------------*/
  1089.     /* Code Body                                                      */
  1090.     /*----------------------------------------------------------------*/
  1091.     SetCMScrnFlag(FALSE);
  1092.     PreEntryScrMessagesMenuList();
  1093.     DeleteScreenIfPresent(SCR1003_CM_ACTIVECALLOPTIONS);    
  1094. }
  1097. /*****************************************************************************
  1098.  * FUNCTION
  1099.  *  HiliteM2032MsgAppEntry
  1100.  * DESCRIPTION
  1101.  *  hilite handler to invoke the Msg App Entry function
  1102.  * PARAMETERS
  1103.  *  void
  1104.  * RETURNS
  1105.  *  void
  1106.  *****************************************************************************/
  1107. void HiliteM2032MsgAppEntry(void)
  1108. {
  1109.     /*----------------------------------------------------------------*/
  1110.     /* Local Variables                                                */
  1111.     /*----------------------------------------------------------------*/
  1113.     /*----------------------------------------------------------------*/
  1114.     /* Code Body                                                      */
  1115.     /*----------------------------------------------------------------*/
  1116.     PRINT_INFORMATION(("n 2032 MsgAppEntry n"));
  1118.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_SCR1003_LSK);
  1119.     SetKeyHandler(DummyPreEntryScrMessagesMenuList, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  1120.     SetLeftSoftkeyFunction(DummyPreEntryScrMessagesMenuList, KEY_EVENT_UP);
  1121.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  1122. }
  1124. #ifdef __MMI_VOICE_MEMO__
  1127. /*****************************************************************************
  1128.  * FUNCTION
  1129.  *  DummyEntryVoiceMemoInCall
  1130.  * DESCRIPTION
  1131.  *  set CM screen flag before go to Voice Memo application
  1132.  * PARAMETERS
  1133.  *  void
  1134.  * RETURNS
  1135.  *  void
  1136.  *****************************************************************************/
  1137. void DummyEntryVoiceMemoInCall(void)
  1138. {
  1139.     /*----------------------------------------------------------------*/
  1140.     /* Local Variables                                                */
  1141.     /*----------------------------------------------------------------*/
  1143.     /*----------------------------------------------------------------*/
  1144.     /* Code Body                                                      */
  1145.     /*----------------------------------------------------------------*/
  1146.     SetCMScrnFlag(FALSE);
  1147.     EntryVoiceMemoInCall();
  1148.     DeleteScreenIfPresent(SCR1003_CM_ACTIVECALLOPTIONS);    
  1149. }
  1152. /*****************************************************************************
  1153.  * FUNCTION
  1154.  *  HiliteM2022VoiceMemo
  1155.  * DESCRIPTION
  1156.  *  hilite handler to invoke the VoiceMemo function
  1157.  * PARAMETERS
  1158.  *  void
  1159.  * RETURNS
  1160.  *  void
  1161.  *****************************************************************************/
  1162. void HiliteM2022VoiceMemo(void)
  1163. {
  1164.     /*----------------------------------------------------------------*/
  1165.     /* Local Variables                                                */
  1166.     /*----------------------------------------------------------------*/
  1168.     /*----------------------------------------------------------------*/
  1169.     /* Code Body                                                      */
  1170.     /*----------------------------------------------------------------*/
  1171.     PRINT_INFORMATION(("n 2022 Voice Memo n"));
  1173.     ClearKeyHandler(KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  1174.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_SCR1003_LSK);
  1175.     SetLeftSoftkeyFunction(DummyEntryVoiceMemoInCall, KEY_EVENT_UP);
  1176.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  1177. }
  1178. #endif /* __MMI_VOICE_MEMO__ */ 
  1180. #ifdef __MMI_SOUND_RECORDER__
  1183. /*****************************************************************************
  1184.  * FUNCTION
  1185.  *  DummyEntrySoundRecorderInCall
  1186.  * DESCRIPTION
  1187.  *  set CM screen flag before go to Sound Recorder application
  1188.  * PARAMETERS
  1189.  *  void
  1190.  * RETURNS
  1191.  *  void
  1192.  *****************************************************************************/
  1193. void DummyEntrySoundRecorderInCall(void)
  1194. {
  1195.     /*----------------------------------------------------------------*/
  1196.     /* Local Variables                                                */
  1197.     /*----------------------------------------------------------------*/
  1199.     /*----------------------------------------------------------------*/
  1200.     /* Code Body                                                      */
  1201.     /*----------------------------------------------------------------*/
  1202.     SetCMScrnFlag(FALSE);
  1203.     mmi_sndrec_entry_in_call();
  1204.     DeleteScreenIfPresent(SCR1003_CM_ACTIVECALLOPTIONS);
  1205. }
  1208. /*****************************************************************************
  1209.  * FUNCTION
  1210.  *  HiliteM2026SoundRecorder
  1211.  * DESCRIPTION
  1212.  *  hilite handler to invoke the VoiceMemo function
  1213.  * PARAMETERS
  1214.  *  void
  1215.  * RETURNS
  1216.  *  void
  1217.  *****************************************************************************/
  1218. void HiliteM2026SoundRecorder(void)
  1219. {
  1220.     /*----------------------------------------------------------------*/
  1221.     /* Local Variables                                                */
  1222.     /*----------------------------------------------------------------*/
  1224.     /*----------------------------------------------------------------*/
  1225.     /* Code Body                                                      */
  1226.     /*----------------------------------------------------------------*/
  1227.     PRINT_INFORMATION(("n 2026 Sound Recorder n"));
  1229.     ClearKeyHandler(KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  1230.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_SCR1003_LSK);
  1231.     SetLeftSoftkeyFunction(DummyEntrySoundRecorderInCall, KEY_EVENT_UP);
  1232.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  1233. }
  1234. #endif /* __MMI_SOUND_RECORDER__ */ 
  1236. #ifdef __MMI_AUDIO_PLAYER__
  1239. /*****************************************************************************
  1240.  * FUNCTION
  1241.  *  DummyEntryAudioPlayerInCall
  1242.  * DESCRIPTION
  1243.  *  set CM screen flag before go to Audio Player application
  1244.  * PARAMETERS
  1245.  *  void
  1246.  * RETURNS
  1247.  *  void
  1248.  *****************************************************************************/
  1249. void DummyEntryAudioPlayerInCall(void)
  1250. {
  1251.     /*----------------------------------------------------------------*/
  1252.     /* Local Variables                                                */
  1253.     /*----------------------------------------------------------------*/
  1255.     /*----------------------------------------------------------------*/
  1256.     /* Code Body                                                      */
  1257.     /*----------------------------------------------------------------*/
  1258.     SetCMScrnFlag(FALSE);
  1259.     mmi_audply_entry_main();
  1260.     DeleteScreenIfPresent(SCR1003_CM_ACTIVECALLOPTIONS);    
  1261. }
  1264. /*****************************************************************************
  1265.  * FUNCTION
  1266.  *  HiliteM2025AudioPlayer
  1267.  * DESCRIPTION
  1268.  *  hilite handler to invoke the AudioPlayer function
  1269.  * PARAMETERS
  1270.  *  void
  1271.  * RETURNS
  1272.  *  void
  1273.  *****************************************************************************/
  1274. void HiliteM2025AudioPlayer(void)
  1275. {
  1276.     /*----------------------------------------------------------------*/
  1277.     /* Local Variables                                                */
  1278.     /*----------------------------------------------------------------*/
  1280.     /*----------------------------------------------------------------*/
  1281.     /* Code Body                                                      */
  1282.     /*----------------------------------------------------------------*/
  1283.     PRINT_INFORMATION(("n 2025 Audio Player n"));
  1285.     ClearKeyHandler(KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  1286.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_SCR1003_LSK);
  1287.     SetLeftSoftkeyFunction(DummyEntryAudioPlayerInCall, KEY_EVENT_UP);
  1288.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  1289. }
  1290. #endif /* __MMI_AUDIO_PLAYER__ */ 
  1292. #if defined(__MMI_BT_HP_SUPPORT__) || defined(__MMI_BT_SUPPORT__)
  1295. /*****************************************************************************
  1296.  * FUNCTION
  1297.  *  HiliteBTCMSetPath
  1298.  * DESCRIPTION
  1299.  *  
  1300.  * PARAMETERS
  1301.  *  void
  1302.  * RETURNS
  1303.  *  void
  1304.  *****************************************************************************/
  1305. void HiliteBTCMSetPath(void)
  1306. {
  1307.     /*----------------------------------------------------------------*/
  1308.     /* Local Variables                                                */
  1309.     /*----------------------------------------------------------------*/
  1311.     /*----------------------------------------------------------------*/
  1312.     /* Code Body                                                      */
  1313.     /*----------------------------------------------------------------*/
  1314.     PRINT_INFORMATION(("n CM--BT Set Voice Path n"));
  1316.     ClearKeyHandler(KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  1317.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_SCR1003_LSK);
  1318.     SetLeftSoftkeyFunction(ProcessBTSetVoicePath, KEY_EVENT_UP);
  1319.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  1320. }
  1323. /*****************************************************************************
  1324.  * FUNCTION
  1325.  *  ProcessBTSetVoicePath
  1326.  * DESCRIPTION
  1327.  *  
  1328.  * PARAMETERS
  1329.  *  void
  1330.  * RETURNS
  1331.  *  void
  1332.  *****************************************************************************/
  1333. void ProcessBTSetVoicePath(void)
  1334. {
  1335.     /*----------------------------------------------------------------*/
  1336.     /* Local Variables                                                */
  1337.     /*----------------------------------------------------------------*/
  1339.     /*----------------------------------------------------------------*/
  1340.     /* Code Body                                                      */
  1341.     /*----------------------------------------------------------------*/
  1342.     if (mmi_bt_is_incall_aud_swap2bt() == MMI_TRUE)
  1343.     {
  1344.         /* Current voice path in BT, shall transfer to AG */
  1345.         mmi_bt_switch_voice_path_incall(MMI_FALSE);
  1346.     #if 0
  1347. /* under construction !*/
  1348. /* under construction !*/
  1349. /* under construction !*/
  1350. /* under construction !*/
  1351. /* under construction !*/
  1352. /* under construction !*/
  1353. /* under construction !*/
  1354. /* under construction !*/
  1355.     #endif /* 0 */ 
  1356.     }
  1357.     else
  1358.     {
  1359.         /* Current voice path in AG, shall transfer to BT */
  1360.         mmi_bt_switch_voice_path_incall(MMI_TRUE);
  1361.     #if 0
  1362. /* under construction !*/
  1363. /* under construction !*/
  1364. /* under construction !*/
  1365. /* under construction !*/
  1366. /* under construction !*/
  1367. /* under construction !*/
  1368. /* under construction !*/
  1369. /* under construction !*/
  1370.     #endif /* 0 */ 
  1372.     }
  1373. }
  1375. #endif /* defined(__MMI_BT_HP_SUPPORT__) || defined(__MMI_BT_SUPPORT__) */ 
  1378. /*****************************************************************************
  1379.  * FUNCTION
  1380.  *  HiliteM2020Mute
  1381.  * DESCRIPTION
  1382.  *  hilite handler to invoke the Mute function
  1383.  * PARAMETERS
  1384.  *  void
  1385.  * RETURNS
  1386.  *  void
  1387.  *****************************************************************************/
  1388. void HiliteM2020Mute(void)
  1389. {
  1390.     /*----------------------------------------------------------------*/
  1391.     /* Local Variables                                                */
  1392.     /*----------------------------------------------------------------*/
  1394.     /*----------------------------------------------------------------*/
  1395.     /* Code Body                                                      */
  1396.     /*----------------------------------------------------------------*/
  1397.     PRINT_INFORMATION(("n 2020 Mute n"));
  1399.     if (IsPhoneInMute())
  1400.     {
  1401.         ChangeLeftSoftkey(STR_GLOBAL_OFF, IMG_SCR1002_OFF_LSK);
  1402.     }
  1403.     else
  1404.     {
  1405.         ChangeLeftSoftkey(STR_GLOBAL_ON, IMG_SCR1002_ON_LSK);
  1406.     }
  1408.     ClearKeyHandler(KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  1409.     SetLeftSoftkeyFunction(OptionMuteorUnMutetheCall, KEY_EVENT_UP);
  1410.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  1411. }
  1414. /*****************************************************************************
  1415.  * FUNCTION
  1416.  *  HiliteM2024DTMF
  1417.  * DESCRIPTION
  1418.  *  hilite handler to invoke the DTMF function
  1419.  * PARAMETERS
  1420.  *  void
  1421.  * RETURNS
  1422.  *  void
  1423.  *****************************************************************************/
  1424. void HiliteM2024DTMF(void)
  1425. {
  1426.     /*----------------------------------------------------------------*/
  1427.     /* Local Variables                                                */
  1428.     /*----------------------------------------------------------------*/
  1430.     /*----------------------------------------------------------------*/
  1431.     /* Code Body                                                      */
  1432.     /*----------------------------------------------------------------*/
  1433.     PRINT_INFORMATION(("n 2024 DTMF n"));
  1435.     if (GetDTMFFlag() == TRUE)
  1436.     {
  1437.         ChangeLeftSoftkey(STR_GLOBAL_OFF, IMG_SCR1002_OFF_LSK);
  1438.     }
  1439.     else
  1440.     {
  1441.         ChangeLeftSoftkey(STR_GLOBAL_ON, IMG_SCR1002_ON_LSK);
  1442.     }
  1444.     ClearKeyHandler(KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  1445.     SetLeftSoftkeyFunction(DTMFFunction, KEY_EVENT_UP);
  1446.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  1447. }
  1449. #ifdef __CTM_SUPPORT__
  1452. /*****************************************************************************
  1453.  * FUNCTION
  1454.  *  HiliteM2027CTM
  1455.  * DESCRIPTION
  1456.  *  hilite handler to invoke the CTM connection
  1457.  * PARAMETERS
  1458.  *  void
  1459.  * RETURNS
  1460.  *  void
  1461.  *****************************************************************************/
  1462. void HiliteM2027CTM(void)
  1463. {
  1464.     /*----------------------------------------------------------------*/
  1465.     /* Local Variables                                                */
  1466.     /*----------------------------------------------------------------*/
  1468.     /*----------------------------------------------------------------*/
  1469.     /* Code Body                                                      */
  1470.     /*----------------------------------------------------------------*/
  1471.     PRINT_INFORMATION(("n 2027 CTM n"));
  1473.     ChangeLeftSoftkey(STR_GLOBAL_OK, 0);
  1474.     ClearKeyHandler(KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  1475.     SetLeftSoftkeyFunction(mmi_ctm_connect, KEY_EVENT_UP);
  1476.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  1477. }
  1478. #endif /* __CTM_SUPPORT__ */ 
  1481. /*****************************************************************************
  1482.  * FUNCTION
  1483.  *  HiliteM2023LoudSp
  1484.  * DESCRIPTION
  1485.  *  hilite handler to invoke the LoudSpeaker function
  1486.  * PARAMETERS
  1487.  *  void
  1488.  * RETURNS
  1489.  *  void
  1490.  *****************************************************************************/
  1491. void HiliteM2023LoudSp(void)
  1492. {
  1493.     /*----------------------------------------------------------------*/
  1494.     /* Local Variables                                                */
  1495.     /*----------------------------------------------------------------*/
  1497.     /*----------------------------------------------------------------*/
  1498.     /* Code Body                                                      */
  1499.     /*----------------------------------------------------------------*/
  1500.     PRINT_INFORMATION(("n 2023 Loud Speaker n"));
  1502.     ClearKeyHandler(KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  1503.     SetLeftSoftkeyFunction(LoudSpeakerFunction /* fromOptions */ , KEY_EVENT_UP);
  1504.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_SCR1003_LSK);
  1505.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  1506. }
  1509. /*****************************************************************************
  1510.  * FUNCTION
  1511.  *  HiliteM2021NewCall
  1512.  * DESCRIPTION
  1513.  *  hilite handler to invoke the NewCall function
  1514.  * PARAMETERS
  1515.  *  void
  1516.  * RETURNS
  1517.  *  void
  1518.  *****************************************************************************/
  1519. void HiliteM2021NewCall(void)
  1520. {
  1521.     /*----------------------------------------------------------------*/
  1522.     /* Local Variables                                                */
  1523.     /*----------------------------------------------------------------*/
  1525.     /*----------------------------------------------------------------*/
  1526.     /* Code Body                                                      */
  1527.     /*----------------------------------------------------------------*/
  1528.     PRINT_INFORMATION(("n 2021 New Call n"));
  1530.     ClearKeyHandler(KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  1531.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_SCR1003_LSK);
  1532.     SetLeftSoftkeyFunction(EnterScreenAndHandleDigit, KEY_EVENT_UP);
  1533.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  1534. }
  1537. /*****************************************************************************
  1538.  * FUNCTION
  1539.  *  Hint2020Mute
  1540.  * DESCRIPTION
  1541.  *  hint handler to get mute status
  1542.  * PARAMETERS
  1543.  *  index       [IN]        
  1544.  * RETURNS
  1545.  *  void
  1546.  *****************************************************************************/
  1547. void Hint2020Mute(U16 index)
  1548. {
  1549.     /*----------------------------------------------------------------*/
  1550.     /* Local Variables                                                */
  1551.     /*----------------------------------------------------------------*/
  1553.     /*----------------------------------------------------------------*/
  1554.     /* Code Body                                                      */
  1555.     /*----------------------------------------------------------------*/
  1556.     if (IsPhoneInMute() == TRUE)
  1557.     {
  1558.         pfnUnicodeStrcpy((S8*) hintData[index], (S8*) GetString(STR_GLOBAL_ON));
  1559.     }
  1560.     else
  1561.     {
  1562.         pfnUnicodeStrcpy((S8*) hintData[index], (S8*) GetString(STR_GLOBAL_OFF));
  1563.     }
  1564.     return;
  1565. }
  1568. /*****************************************************************************
  1569.  * FUNCTION
  1570.  *  Hint2024DTMF
  1571.  * DESCRIPTION
  1572.  *  hint handler to get dtmf status
  1573.  * PARAMETERS
  1574.  *  index       [IN]        
  1575.  * RETURNS
  1576.  *  void
  1577.  *****************************************************************************/
  1578. void Hint2024DTMF(U16 index)
  1579. {
  1580.     /*----------------------------------------------------------------*/
  1581.     /* Local Variables                                                */
  1582.     /*----------------------------------------------------------------*/
  1584.     /*----------------------------------------------------------------*/
  1585.     /* Code Body                                                      */
  1586.     /*----------------------------------------------------------------*/
  1587.     if (GetDTMFFlag() == TRUE)
  1588.     {
  1589.         pfnUnicodeStrcpy((S8*) hintData[index], (S8*) GetString(STR_GLOBAL_ON));
  1590.     }
  1591.     else
  1592.     {
  1593.         pfnUnicodeStrcpy((S8*) hintData[index], (S8*) GetString(STR_GLOBAL_OFF));
  1594.     }
  1595.     return;
  1596. }
  1599. /*****************************************************************************
  1600.  * FUNCTION
  1601.  *  MakeMOForAT
  1602.  * DESCRIPTION
  1603.  *  Makes MO Call from AT Command
  1604.  * PARAMETERS
  1605.  *  num             [IN]        
  1606.  *  length          [IN]        
  1607.  *  callType        [IN]        
  1608.  * RETURNS
  1609.  *  void
  1610.  *****************************************************************************/
  1611. void MakeMOForAT(PS8 num, U8 length, U8 callType)
  1612. {
  1613.     /*----------------------------------------------------------------*/
  1614.     /* Local Variables                                                */
  1615.     /*----------------------------------------------------------------*/
  1616.     PHB_CM_INTERFACE phb_data;
  1618.     /*----------------------------------------------------------------*/
  1619.     /* Code Body                                                      */
  1620.     /*----------------------------------------------------------------*/
  1621.     if (GetCurrentState() == CM_OUTGOING_STATE)
  1622.     {
  1623.         if (cm_p->redial_info.RedialTimer == TRUE)
  1624.         {
  1625.             /* stop redialing */
  1626.             ResetRedialAttempts();
  1627.             SetCurrentState(CM_IDLE_STATE);
  1628.         }
  1629.         else
  1630.         {
  1631.             /* already MO, ignore it */
  1632.             return;
  1633.         }
  1634.     }
  1636.     memset(&gCurrOutcall, 0, sizeof(OUTGOING_CALL));
  1637.     if (strlen((void*)num) > MAX_DIGIT)
  1638.     {
  1639.         PRINT_INFORMATION(("XXX Number too big XXX n"));
  1640.         ShowCallManagementErrorMessage(ERR_INVALID_NUMBER_FORMAT);
  1641.         return;
  1642.     }
  1644.     if (length > 0)
  1645.     {
  1646.         AnsiiToUnicodeString((PS8) gCurrOutcall.Number, (PS8) num);
  1647.     }
  1649.     SetPreviousState((CALL_STATE) GetCurrentState());
  1650.     SetCurrentState(CM_OUTGOING_STATE);
  1652.     gtmpOutgoingIndex = GetFirstFreeIndex();
  1653.     AddNewCallInfo(
  1654.         (PU8) gCurrOutcall.Number,
  1655.         GetCurrentState(),
  1656.         GetPreviousState(),
  1657.         CM_CALL_MO,
  1658.         (CM_CALL_HANDLE) (gtmpOutgoingIndex + 1),
  1659.         callType);
  1661.     SetCCFlag(TRUE);
  1662.     SetDialIndication(FALSE);
  1664.     /* MO call */
  1665.     /* look up dialed number from phonebook first anyway */
  1666.     if (length > 0)
  1667.     {
  1668.     phb_data = mmi_phb_call_get_data_for_call_mgnt((PU8) gCurrOutcall.Number, FALSE);
  1669.     SetCMPhoneBookStruct(&phb_data);
  1670.     SetOutgoingNamefromPhonebook();
  1671.     }    
  1673.     if (callType == CM_CSD_CALL)
  1674.     {
  1675.         stopRequestedTone(MESSAGE_TONE);
  1676.     }
  1677. #ifdef __MMI_BT_PROFILE__
  1678.     else
  1679.     {
  1680.         /* stop audio background play before sco link */
  1681.         mdi_audio_suspend_background_play();
  1682.         /* establish sco link here */
  1683.         mmi_profiles_bt_call_start_callback();
  1684.     }
  1685. #endif /* __MMI_BT_PROFILE__ */ 
  1687.     AlmDisableExpiryHandler();
  1688.     SetProtocolEventHandler(OutgoingCallConnected, PRT_OUTGOINGCALL_CONNECTED);
  1689.     OutgoingProcessCMEvent(CM_PS_SHOW_OUTGOING_CALL_SCREEN, NULL);
  1690. }
  1693. /*****************************************************************************
  1694.  * FUNCTION
  1695.  *  OutgoingProcessCMEvent
  1696.  * DESCRIPTION
  1697.  *  This is the Entry function for all the Events while the Call-Management application
  1698.  *  is Active.
  1699.  *  
  1700.  *  This function handles the events from both keyboard and protocol stack.
  1701.  *  The keyboard events have KB in there defination and Protocol has PS.
  1702.  * PARAMETERS
  1703.  *  inEvenType      [IN]        
  1704.  *  MsgStruct       [?]         
  1705.  *  pointer(?)      [IN]        To the event's associated structure)
  1706.  * RETURNS
  1707.  *  void
  1708.  *****************************************************************************/
  1709. void OutgoingProcessCMEvent(CM_EVENT_TYPES inEvenType, void *MsgStruct)
  1710. {
  1711.     /*----------------------------------------------------------------*/
  1712.     /* Local Variables                                                */
  1713.     /*----------------------------------------------------------------*/
  1714.     ACTION_RESULT result = CM_CALL_FAILURE;
  1716.     /*----------------------------------------------------------------*/
  1717.     /* Code Body                                                      */
  1718.     /*----------------------------------------------------------------*/
  1719.     PRINT_INFORMATION(("XXX In OutgoingProcessCMEventn"));
  1721.     switch (inEvenType)
  1722.     {
  1723.         case CM_PS_SHOW_OUTGOING_CALL_SCREEN:
  1724.             ProcessShowOutgoingCallScreen();
  1725.             break;
  1727.         case CM_PS_SHOW_REQUESTING_CALL_SCREEN:
  1728.             if (GetActiveScreenId() == SCR_CM_REQUESTINGUSSD)
  1729.             {
  1730.                 /* current active screen is SS requesting, display and remove previous*/
  1731.                 EntryScrUSSDReq();
  1732.                 RemoveSSReqScr();
  1733.                 SetDelScrnIDCallbackHandler(SCR_CM_REQUESTINGUSSD, (HistoryDelCBPtr) SSReqHistoryDelHdlr);                
  1734.             }
  1735.             else if (IsScreenPresent(SCR_CM_REQUESTINGUSSD))
  1736.             {
  1737.                 /* SS requesting screen is in history, do nothing */
  1738.             }
  1739.             else
  1740.             {
  1741.                 /* current active screen is NOT SS requesting, not in history also, display requesting screen*/
  1742.                 EntryScrUSSDReq();
  1743.             }
  1744.             
  1745.             /* if (IsScreenPresent(CM_SCR_MARKER) == FALSE)
  1746.                AddMarkerToHistory(); */
  1747.             break;
  1749.         case CM_PS_USSD_RECVD:
  1750.             ProcessUSSDrecieved(MsgStruct);
  1751.             break;
  1753.         case CM_KB_OUTGOINGCALL:
  1754.             /* MO SEND key */
  1755.             result = ProcessKBOutgoingEvent(MsgStruct);
  1756.             break;
  1758.         case CM_PS_CALLCONNECTED:
  1759.             /* connect ind */
  1760.             result = ProcessPSCallconnectedEvent(MsgStruct);
  1761.             break;
  1763.         case CM_KB_HANGUPREQ:
  1764.             /* 1X send, drop single call */
  1765.             result = ProcessKBHangupReqEvent(MsgStruct);
  1766.             break;
  1768.         case CM_PS_HANGUPSUC:
  1769.             result = ProcessPSHangupSucEvent(MsgStruct);
  1770.             break;
  1772.         case CM_KB_HANGUPALLREQ:
  1773.             /* END key in CM */
  1774.             result = ProcessKBHangupallReqEvent(MsgStruct);
  1775.             break;
  1777.         case CM_PS_HANGUPALLSUC:
  1778.             result = ProcessPSHangupallSucEvent(MsgStruct);
  1779.             break;
  1781.         case CM_KB_HANGUPALLACTREQ:
  1782.             /* Menu End All Active */
  1783.             result = ProcessKBHangupallActReqEvent(MsgStruct);
  1784.             break;
  1786.         case CM_PS_HANGUPALLACTSUC:
  1787.             result = ProcessPSHangupallActSucEvent(MsgStruct);
  1788.             break;
  1790.         case CM_KB_HANGUPALLHLDREQ:
  1791.             result = ProcessKBHangupallHldReqEvent(MsgStruct);
  1792.             break;
  1794.         case CM_PS_HANGUPALLHLDSUC:
  1795.             result = ProcessPSHangupallHldSucEvent(MsgStruct);
  1796.             break;
  1798.         case CM_KB_HOLDREQ:
  1799.             result = ProcessKBHoldReqEvent(MsgStruct);
  1800.             break;
  1802.         case CM_PS_HOLDSUC:
  1803.             result = ProcessPSHoldSucEvent(MsgStruct);
  1804.             break;
  1806.         case CM_KB_RETRIEVEREQ:
  1807.             result = ProcessKBRetrieveReqEvent(MsgStruct);
  1808.             break;
  1810.         case CM_PS_RETRIEVESUC:
  1811.             result = ProcessPSRetrieveSucEvent(MsgStruct);
  1812.             break;
  1814.         case CM_KB_SWAPREQ:
  1815.             result = ProcessKBSwapReqEvent(MsgStruct);
  1816.             break;
  1818.         case CM_PS_SWAPSUC:
  1819.             result = ProcessPSSwapSucEvent(MsgStruct);
  1820.             break;
  1822.         case CM_KB_CONFREQ:
  1823.             result = ProcessKBConfReqEvent(MsgStruct);
  1824.             break;
  1826.         case CM_PS_CONFSUC:
  1827.             result = ProcessPSConfSucEvent(MsgStruct);
  1828.             break;
  1830.         case CM_KB_SPLITREQ:
  1831.             result = ProcessKBSplitReqEvent(MsgStruct);
  1832.             break;
  1834.         case CM_PS_SPLITSUC:
  1835.             result = ProcessPSSplitSucEvent(MsgStruct);
  1836.             break;
  1838.         case CM_KB_ECT_REQ:
  1839.             result = ProcessKBEctReqEvent(MsgStruct);
  1840.             break;
  1842.              case CM_PS_ECT_SUC:
  1843.                result=ProcessPSEctSuccessful(MsgStruct);
  1844.                break; 
  1846.         case CM_KB_CALL_DEFLECT_REQ:
  1847.             MakePsCallDeflect((void*)PsCBackCallDeflected, (PU8) MsgStruct);
  1848.             ShowCategory302Screen(NULL);
  1849.             break;
  1851.         case CM_PS_INCOMING_CALL_DEFLECT:
  1852.             ShowCategory302Screen(NULL);
  1853.             break;
  1855.         default:
  1856.             PRINT_INFORMATION(("n CM Event Handler does not exist n"));
  1857.             break;
  1858.     }
  1859.     PRINT_INFORMATION_2((MMI_TRACE_G5_CM, "*-------[OutgoingCallManagement.c] OutgoingProcessCMEvent: result = "
  1860.                          " %d-------*n", (int)result));
  1861. }
  1864. /*****************************************************************************
  1865.  * FUNCTION
  1866.  *  ProcessShowOutgoingCallScreen
  1867.  * DESCRIPTION
  1868.  *  This is the function to show outgoing call only when the Call list is recieved
  1869.  *  
  1870.  *  This invokes the protocol function if the state is in Idle/hold state.
  1871.  *  In Active state,it makes the request to hold and after success it initiates the call.
  1872.  * PARAMETERS
  1873.  *  void
  1874.  *  void(?)                 [IN]        *(this points to OUTGOING_CALL structure)
  1875.  *  ACTION_RESULT(?)        [OUT]       
  1876.  * RETURNS
  1877.  *  This returns CM_CALL_SUCCESS if success or CM_CALL_FAILURE if failure.(?)
  1878.  *****************************************************************************/
  1879. void ProcessShowOutgoingCallScreen(void)
  1880. {
  1881.     /*----------------------------------------------------------------*/
  1882.     /* Local Variables                                                */
  1883.     /*----------------------------------------------------------------*/
  1885.     /*----------------------------------------------------------------*/
  1886.     /* Code Body                                                      */
  1887.     /*----------------------------------------------------------------*/
  1888.     PRINT_INFORMATION(("XXX In ProcessShowOutgoingCallScreen n"));
  1890.     switch (GetPreviousState())
  1891.     {
  1892.         case CM_IDLE_STATE:
  1893.             /* do not have to suspend audio for CSD call */
  1894.             EntryScr1001OutgoingCall();
  1895.             if (GetOutgoingCallType() != CM_CSD_CALL)
  1896.             {
  1897.                 mdi_audio_suspend_background_play();
  1898.             }
  1899.             if (IsScreenPresent(CM_SCR_MARKER) == FALSE)
  1900.             {
  1901.                 AddMarkerToHistory();
  1902.             }
  1903.             break;
  1905.         case CM_INCOMING_STATE:
  1906.         case CM_HOLD_STATE:
  1907.         case CM_ACTIVE_STATE:
  1908.             EntryScr1001OutgoingCall();
  1909.             if (GetOutgoingCallOrigin() == CM_CALL_MO_STK)
  1910.             {
  1911.                 AddMarkerToHistory();
  1912.             }
  1913.             break;
  1915.         default:
  1916.             PRINT_INFORMATION(("n KBOutgoingEvent CM State Machine is in incorrect state n"));
  1917.             break;
  1918.     }
  1919. }
  1922. /*****************************************************************************
  1923.  * FUNCTION
  1924.  *  ProcessKBOutgoingEvent
  1925.  * DESCRIPTION
  1926.  *  This is the function to process Keyboard(Request) Event CM_KB_OUTGOINGCALL.
  1927.  *  
  1928.  *  This invokes the protocol function if the state is in Idle/hold state.
  1929.  *  In Active state,it makes the request to hold and after success it initiates the call.
  1930.  * PARAMETERS
  1931.  *  MsgStruct               [?]         
  1932.  *  ACTION_RESULT(?)        [OUT]       
  1933.  *  this(?)                 [IN]        Points to OUTGOING_CALL structure)
  1934.  * RETURNS
  1935.  *  This returns CM_CALL_SUCCESS if success or CM_CALL_FAILURE if failure.
  1936.  *****************************************************************************/
  1937. ACTION_RESULT ProcessKBOutgoingEvent(void *MsgStruct)
  1938. {
  1939.     /*----------------------------------------------------------------*/
  1940.     /* Local Variables                                                */
  1941.     /*----------------------------------------------------------------*/
  1943.     /*----------------------------------------------------------------*/
  1944.     /* Code Body                                                      */
  1945.     /*----------------------------------------------------------------*/
  1946.     memcpy(&gCurrOutcall, MsgStruct, sizeof(OUTGOING_CALL));
  1948.     switch (GetCurrentState())
  1949.     {
  1950.         case CM_IDLE_STATE:
  1951.             if (AllowMoreCalls() && DTMFPadCallBuffer[0] != 0)
  1952.             {
  1953.                 SetPreviousState(CM_IDLE_STATE);
  1954.                 SetCurrentState(CM_OUTGOING_STATE);
  1956.                 gtmpOutgoingIndex = GetFirstFreeIndex();
  1957.                 AddNewCallInfo(
  1958.                     gCurrOutcall.Number,
  1959.                     CM_OUTGOING_STATE,
  1960.                     CM_IDLE_STATE,
  1961.                     CM_CALL_MO,
  1962.                     (CM_CALL_HANDLE) (gtmpOutgoingIndex + 1),
  1963.                     CSMCC_VOICE_CALL);
  1965.                 MakePsInitiateCall((PU8) DTMFPadCallBuffer, (void*)OutgoingCallConnected);
  1966.             }
  1967.             else
  1968.             {
  1969.                 ShowCallManagementErrorMessage(NO_ACTIVE_CALL);
  1970.                 return CM_CALL_FAILURE;
  1971.             }
  1972.             break;
  1974.         case CM_OUTGOING_STATE:
  1975.             PRINT_INFORMATION(("XXX In ProcessKBOutgoingEvent already outgoing, can't make MOn"));
  1976.             ShowCallManagementErrorMessage(ERR_L4C_GEN_CAUSE);
  1977.             return CM_CALL_FAILURE;
  1979.         case CM_INCOMING_STATE:
  1980.         case CM_HOLD_STATE:
  1981.         case CM_ACTIVE_STATE:
  1982.             /* send SS when MT call and previous USSR seession exists,
  1983.                need to abort previous session */
  1984.             DeleteScreenIfPresent(ITEM_SCR_USSN_MSG);
  1985.             DeleteScreenIfPresent(ITEM_SCR_USSR_EDIT);
  1987.             if (AllowMoreCalls())
  1988.             {
  1989.                 SetPreviousState(GetCurrentState());
  1990.                 SetCurrentState(CM_OUTGOING_STATE);
  1992.                 gtmpOutgoingIndex = GetFirstFreeIndex();
  1993.                 AddNewCallInfo(
  1994.                     gCurrOutcall.Number,
  1995.                     GetCurrentState(),
  1996.                     CM_IDLE_STATE,
  1997.                     CM_CALL_MO,
  1998.                     (CM_CALL_HANDLE) (gtmpOutgoingIndex + 1),
  1999.                     CSMCC_VOICE_CALL);
  2001.                 MakePsInitiateCall((PU8) DTMFPadCallBuffer, (void*)OutgoingCallConnected);
  2002.             }
  2003.             else
  2004.             {
  2005.                 ShowCallManagementErrorMessage(NO_ACTIVE_CALL);
  2006.                 return CM_CALL_FAILURE;
  2007.             }
  2008.             break;
  2010.         default:
  2011.             PRINT_INFORMATION(("n KBOutgoingEvent CM State m/c Corrupted n"));
  2012.             return CM_CALL_FAILURE;
  2013.     }
  2015.     return CM_CALL_SUCCESS;
  2016. }
  2019. /*****************************************************************************
  2020.  * FUNCTION
  2021.  *  ProcessPSCallconnectedEvent
  2022.  * DESCRIPTION
  2023.  *  This is the function to process Protocol(Response) Event CM_PS_CALLCONNECTED.
  2024.  *  
  2025.  *  This change the state of the call to ACTIVE & also changes the
  2026.  *  state of the State m/c.
  2027.  * PARAMETERS
  2028.  *  MsgStruct               [?]         
  2029.  *  ACTION_RESULT(?)        [OUT]       
  2030.  *  this(?)                 [IN]        Points to CM_CALL_HANDLE of the call which requested CM_KB_OUTGOINGCALL)
  2031.  * RETURNS
  2032.  *  This returns CM_CALL_SUCCESS if success or CM_CALL_FAILURE if failure.
  2033.  *****************************************************************************/
  2034. ACTION_RESULT ProcessPSCallconnectedEvent(void *MsgStruct)
  2035. {
  2036.     /*----------------------------------------------------------------*/
  2037.     /* Local Variables                                                */
  2038.     /*----------------------------------------------------------------*/
  2039.     CM_CALL_HANDLE callHandle;
  2040.     CM_CALL_HANDLE *handle;
  2042.     /*----------------------------------------------------------------*/
  2043.     /* Code Body                                                      */
  2044.     /*----------------------------------------------------------------*/
  2045.     handle = (CM_CALL_HANDLE*) MsgStruct;
  2046.     callHandle = *handle;
  2047.     //SetCallHandleForStartTimeUpdate(callHandle);
  2049.     if (callHandle == -1)
  2050.     {
  2051.         PRINT_INFORMATION(("n PSCallconnectedEvent Getting the Connected Handle has -1 n"));
  2052.         return CM_CALL_FAILURE;
  2053.     }
  2055.     switch (GetCurrentState())
  2056.     {
  2057.         case CM_IDLE_STATE:
  2058.             PRINT_INFORMATION(("n PSCallconnectedEvent CM_IDLE_STATE not handled still n"));
  2059.             break;
  2061.         case CM_OUTGOING_STATE:
  2062.             MakeHold();
  2063.             SetPreviousState(GetCurrentState());
  2064.             SetCurrentState(CM_ACTIVE_STATE);
  2066.             SetCallState(gtmpOutgoingIndex, CM_ACTIVE_STATE, FALSE);
  2068.             if (GetWapCallPresent())
  2069.             {
  2070.                 ShowSubLCDScreen(EntrySubLcdScr1002ActiveCall);
  2071.                 CMGetExactTime(UpdateCallStartTimeforWapCall);
  2073.                 /* in wap call => no marker in history */
  2074.                 if (IsScreenPresent(CM_SCR_MARKER))
  2075.                 {
  2076.                     DeleteNScrId(CM_SCR_MARKER);
  2077.                     GoBackHistory();
  2079.                 }
  2080.                 else
  2081.                 {
  2082.                     GoBackHistory();
  2083.                 }
  2084.                 break;
  2085.             }
  2087.             if (GetTotalCallCount() > 1)
  2088.             {
  2089.                 CM_CALL_HANDLE handle;
  2091.                 handle = GetIncomingCallHandle();
  2092.                 if (handle != -1)
  2093.                 {
  2094.                     PHB_CM_INTERFACE phb_data;
  2096.                     SetPreviousState(CM_ACTIVE_STATE);
  2097.                     SetCurrentState(CM_INCOMING_STATE);
  2098.                     if (GetNotifySSFlag() == TRUE)
  2099.                     {
  2100.                         SetNotifySSFlag(FALSE);
  2101.                         SetCbackAfterSS(NULL);
  2102.                     }
  2103.                     /* initiate call start time without get into active call screen */
  2104.                     CMGetExactTime(UpdateCallStartTimeforWapCall);
  2106.                     /* MT call caller picture, ringtone...will be overwrite by MO call, 
  2107.                        it needs to be restored after MO call connected */
  2108.                     phb_data = mmi_phb_call_get_data_for_call_mgnt(GetCallNumber(handle), FALSE);
  2109.                 #ifdef __MMI_INCOMING_CALL_VIDEO__
  2110.                     /* waiting call and ccbs invoke can't use video for display */
  2111.                     if (GetTotalCallCount() > 0 || GetCCBSFlag() == TRUE)
  2112.                     {
  2113.                         phb_data.videoId = 0;
  2114.                     }
  2115.                 #endif /* __MMI_INCOMING_CALL_VIDEO__ */ 
  2116.                     SetCMPhoneBookStruct(&phb_data);
  2118.                     GoBackToHistory(ITEMSCR_INCOMING_CALL);
  2119.                 }
  2120.                 else
  2121.                 {
  2122.                     GoBackToHistory(SCR_CM_ACTIVECALLSCREEN);
  2123.                 }
  2124.             }
  2125.             else
  2126.             {
  2127.                 if (IsScreenPresent(SCR_CM_ACTIVECALLSCREEN))
  2128.                 {
  2129.                     /* check if entering SMS application in call */
  2130.                     if (IsScreenPresent(SCR_ID_MSG_MAIN_MENU_NO_MMS))
  2131.                     {
  2132.                         mmi_frm_sms_delete_action_pending();
  2133.                     }
  2134.                     GoBackToHistory(SCR_CM_ACTIVECALLSCREEN);
  2135.                 }
  2136.                 else
  2137.                 {
  2138.                     EntryScr1002ActiveCall();
  2139.                     /* check if entering SMS application in call */
  2140.                     if (IsScreenPresent(SCR_ID_MSG_MAIN_MENU_NO_MMS))
  2141.                     {
  2142.                         mmi_frm_sms_delete_action_pending();
  2143.                     }
  2144.                     DeleteUptoCmScreen();
  2145.                 }
  2146.             }
  2147.             break;
  2149.         case CM_INCOMING_STATE:
  2150.             PRINT_INFORMATION(("n PSCallconnectedEvent CM_INCOMING_STATE not handled still n"));
  2151.             break;
  2153.         case CM_ACTIVE_STATE:
  2154.             PRINT_INFORMATION(("n PSCallconnectedEvent CM_ACTIVE_STATE not handled still n"));
  2155.             break;
  2157.         case CM_HOLD_STATE:
  2158.             PRINT_INFORMATION(("n PSCallconnectedEvent CM_HOLD_STATE not handled still n"));
  2159.             break;
  2161.         default:
  2162.             PRINT_INFORMATION(("n PSCallconnectedEvent CM State m/c Corrupted n"));
  2163.             return CM_CALL_FAILURE;
  2164.     }
  2165.     return CM_CALL_SUCCESS;
  2166. }
  2169. /*****************************************************************************
  2170.  * FUNCTION
  2171.  *  ProcessKBHangupReqEvent
  2172.  * DESCRIPTION
  2173.  *  This is the function to process Keyboard(Request) Event CM_KB_HANGUPREQ.
  2174.  *  
  2175.  *  This Sets the flag CM_HANGUP_REQUESTED and invoke the protocol function irrespective of the state.
  2176.  *  The chances of this being invoked in idle state is very less.
  2177.  * PARAMETERS
  2178.  *  MsgStruct               [?]         
  2179.  *  ACTION_RESULT(?)        [OUT]       
  2180.  *  this(?)                 [IN]        Points to CM_CALL_HANDLE of the call to get dropped)
  2181.  * RETURNS
  2182.  *  This returns CM_CALL_SUCCESS if success or CM_CALL_FAILURE if failure.
  2183.  *****************************************************************************/
  2184. ACTION_RESULT ProcessKBHangupReqEvent(void *MsgStruct)
  2185. {
  2186.     /*----------------------------------------------------------------*/
  2187.     /* Local Variables                                                */
  2188.     /*----------------------------------------------------------------*/
  2189.     CM_CALL_HANDLE handle;
  2190.     CALL_STATE state;
  2192.     /*----------------------------------------------------------------*/
  2193.     /* Code Body                                                      */
  2194.     /*----------------------------------------------------------------*/
  2195.     PRINT_INFORMATION(("XXX In ProcessKBHangupReqEventn"));
  2197.     if (GetInternalAlert() == TRUE)
  2198.     {
  2199.         StopInternalOutgoingTone();
  2200.     }
  2202.     handle = *((CM_CALL_HANDLE*) MsgStruct);
  2204.     state = GetCallState(handle);
  2205.     switch (GetCurrentState())
  2206.     {
  2207.         case CM_IDLE_STATE:
  2208.             PRINT_INFORMATION(("nKBHangupEvent CM_IDLE_STATE not handled still n"));
  2209.             break;
  2210.         case CM_OUTGOING_STATE:
  2211.             SetCallflag(handle, CM_HANGUP_REQUESTED, TRUE);
  2212.             if (state == CM_ACTIVE_STATE || state == CM_HOLD_STATE || state == CM_INCOMING_STATE)
  2213.             {
  2214.                 /* Start by Julia: Drop call refinement */
  2215.                 SetCallState(handle, CM_DISCONNECTING_STATE, TRUE);
  2216.                 //EntryScr1001OutgoingCall();
  2217.                 // End by Julia
  2218.                 MakePsEndSelectiveCall((void*)HangupReqSucess, handle);
  2219.             }
  2220.             else if ((GetDialIndication() == FALSE) || (GetOutgoingCallType() == CM_CSD_CALL))
  2221.             {
  2222.                 SetCallAbortReqSentFlag(TRUE);
  2223.                 /* Start by Julia: Drop call refinement */
  2224.                 handle = GetOutgoingCallHandle();
  2225.                 SetCallState(handle, CM_DISCONNECTING_STATE, TRUE);
  2226.                 //EntryScr1001OutgoingCall();
  2227.                 // End by Julia
  2228.                 MakePsAthRequest((void*)PsCBackOutgoingCallEnded);
  2229.             }
  2230.             else
  2231.             {
  2232.                 /* Start by Julia: Drop call refinement */
  2233.                 SetCallState(handle, CM_DISCONNECTING_STATE, TRUE);
  2234.                 //EntryScr1001OutgoingCall();
  2235.                 // End by Julia
  2236.                 MakePsEndSelectiveCall((void*)HangupReqSucess, handle);
  2237.             }
  2238.             break;
  2239.         case CM_INCOMING_STATE:
  2240.             // Start by Julia: Drop call refinement
  2241.             // Drop call refinement is not applicable when waiting call exists
  2242.             SetCallflag(handle, CM_HANGUP_REQUESTED, TRUE);
  2243.             MakePsEndSelectiveCall((void*)HangupReqSucess, handle);
  2244.             break;
  2245.             /* End by Julia */
  2246.         case CM_ACTIVE_STATE:
  2247.         case CM_HOLD_STATE:
  2248.             SetCallflag(handle, CM_HANGUP_REQUESTED, TRUE);
  2249.             /* Start by Julia: Drop call refinement */
  2250.             SetCallState(handle, CM_DISCONNECTING_STATE, TRUE);
  2251.             //EntryScr1002ActiveCall();
  2252.             // End by Julia
  2253.             MakePsEndSelectiveCall((void*)HangupReqSucess, handle);
  2254.             break;
  2255.         default:
  2256.             PRINT_INFORMATION(("n KBHangupEvent CM State m/c Corrupted n"));
  2257.             return CM_CALL_FAILURE;
  2258.     }
  2259.     return CM_CALL_SUCCESS;
  2260. }
  2263. /*****************************************************************************
  2264.  * FUNCTION
  2265.  *  ProcessPSHangupSucEvent
  2266.  * DESCRIPTION
  2267.  *  This is the function to process Protocol(Response) Event CM_PS_HANGUPSUC.
  2268.  *  
  2269.  *  This resets the CM_HANGUP_REQUESTED flag and then change the states of the call to IDLE
  2270.  *  if necessary it also changes the state of the State m/c.
  2271.  * PARAMETERS
  2272.  *  MsgStruct               [?]         
  2273.  *  ACTION_RESULT(?)        [OUT]       
  2274.  *  this(?)                 [IN]        Points to CM_CALL_HANDLE of the call which requested CM_KB_HANGUPREQ)
  2275.  * RETURNS
  2276.  *  This returns CM_CALL_SUCCESS if success or CM_CALL_FAILURE if failure.
  2277.  *****************************************************************************/
  2278. ACTION_RESULT ProcessPSHangupSucEvent(void *MsgStruct)
  2279. {
  2280.     /*----------------------------------------------------------------*/
  2281.     /* Local Variables                                                */
  2282.     /*----------------------------------------------------------------*/
  2283.     CM_CALL_HANDLE *handle;
  2284.     U8 flag = FALSE;
  2286.     /*----------------------------------------------------------------*/
  2287.     /* Code Body                                                      */
  2288.     /*----------------------------------------------------------------*/
  2289.     PRINT_INFORMATION(("XXX In ProcessPSHangupSucEvent XXX"));
  2290.     PRINT_INFORMATION(("n X@X@X@X!!n"));
  2292.     handle = (CM_CALL_HANDLE*) MsgStruct;
  2293.     if ((*handle == -1) || (GetMMIStructIndexof(*handle) == -1))
  2294.     {
  2295.         PRINT_INFORMATION(("nBad call handle -1 in HangupSucn"));
  2296.     #ifdef __MMI_VOIP__
  2297.         /* call back voip to connect voip */
  2298.         if ((mmi_voip_app_total_call() != 0) && (mmi_voip_app_get_conn_flag() == MMI_VOIP_CALL_CONN_VOIP))
  2299.         {
  2300.             mmi_voip_app_set_conn_flag(MMI_VOIP_CALL_CONN_NONE);
  2301.             mmi_voip_entry_ans_to_conn_voip();
  2302.         }
  2303.     #endif /* __MMI_VOIP__ */
  2304.         return CM_CALL_FAILURE;
  2305.     }
  2307.     switch (GetCurrentState())
  2308.     {
  2309.         case CM_IDLE_STATE:
  2310.             PRINT_INFORMATION(("n PSHangupSucEvent CM_IDLE_STATE not handled still n"));
  2311.             break;
  2313.         case CM_OUTGOING_STATE:
  2314.             PRINT_INFORMATION(("XXX In ProcessPSHangupSucEvent : Outgoing StateXXX"));
  2315.             LogCallInfoForCallHistory(*handle);
  2316.             if (GetCallState(*handle) == CM_OUTGOING_STATE)
  2317.             {
  2318.                 PRINT_INFORMATION(("XXX In ProcessPSHangupSucEvent : Call being dropped is outgoingXXX"));
  2319.                 flag = TRUE;
  2320.                 GetEndTimeAndNotifyCallAborted();
  2321.                 if (GetOutgoingCallOrigin() == CM_CALL_MO_STK)
  2322.                 {
  2323.                     SATCallExitCause(SAT_CALL_DISCONNECT_BEFORE_CONNECT);
  2324.                 }
  2325.             }
  2326.             else
  2327.             {
  2328.                 GetEndTimeAndNotifyEndCallDuration(*handle);
  2329.             }
  2330.         #ifdef __IP_NUMBER__
  2331.             SetTempUseIPNumber(FALSE);
  2332.         #endif 
  2333.             ResetCallflag((*handle), CM_HANGUP_REQUESTED, TRUE);
  2334.             SetCallState((*handle), CM_IDLE_STATE, TRUE);
  2335.             if (GetTotalCallCount() == 0)
  2336.             {
  2337.                 PRINT_INFORMATION(("XXX In ProcessPSHangupSucEvent :GetTotalCallCount=0XXX"));
  2338.                 SetPreviousState(GetCurrentState());
  2339.                 SetCurrentState(CM_IDLE_STATE);
  2340.             }
  2341.             else
  2342.             {
  2343.                 PRINT_INFORMATION(("XXX In ProcessPSHangupSucEvent :GetTotalCallCount not 0 XXX"));
  2344.                 if (flag)
  2345.                 {
  2346.                     SetCurrentState(GetPreviousState());
  2347.                     SetPreviousState(CM_OUTGOING_STATE);
  2348.                 }
  2349.                 else if (CM_OUTGOING_STATE == GetCurrentState())
  2350.                 {
  2351.                     break;
  2352.                 }
  2354.                 if (GetTotalCallCount() == GetTotalHoldCallCount())
  2355.                 {
  2356.                     SetPreviousState(GetCurrentState());
  2357.                     SetCurrentState(CM_HOLD_STATE);
  2358.                 }
  2359.             }
  2360.             break;
  2362.         case CM_INCOMING_STATE:
  2363.             PRINT_INFORMATION(("XXX In ProcessPSHangupSucEvent : Incoming StateXXX"));
  2364.             LogCallInfoForCallHistory(*handle);
  2365.             /* rel active and accept waiting but waiting is released by network */
  2366.             if (GetIncomingCallHandle() == *handle)
  2367.             {
  2368.                 SetCurrentState(GetPreviousState());
  2369.                 SetPreviousState(CM_INCOMING_STATE);
  2370.                 SetCallState((*handle), CM_IDLE_STATE, TRUE);
  2371.             }
  2372.             else
  2373.             {
  2374.                 GetEndTimeAndNotifyEndCallDuration(*handle);
  2375.                 SetCallState((*handle), CM_IDLE_STATE, TRUE);
  2377.                 if (GetTotalActiveCallCount() != 0)
  2378.                 {
  2379.                     SetPreviousState(CM_ACTIVE_STATE);
  2380.                 }
  2381.                 else if (GetTotalHoldCallCount() != 0)
  2382.                 {
  2383.                     SetPreviousState(CM_HOLD_STATE);
  2384.                 }
  2385.             }
  2386.             break;
  2388.         case CM_HOLD_STATE:
  2389.         case CM_ACTIVE_STATE:
  2390.             PRINT_INFORMATION(("XXX In ProcessPSHangupSucEvent : HOLD/Active StateXXX"));
  2391.             LogCallInfoForCallHistory(*handle);
  2392.             GetEndTimeAndNotifyEndCallDuration(*handle);
  2393.             ResetCallflag((*handle), CM_HANGUP_REQUESTED, TRUE);
  2394.             SetCallState((*handle), CM_IDLE_STATE, TRUE);
  2396.             if (GetTotalCallCount() == 0)
  2397.             {
  2398.                 SetPreviousState(GetCurrentState());
  2399.                 SetCurrentState(CM_IDLE_STATE);
  2400.             }
  2401.             else if ((GetTotalActiveCallCount() == 0) && (GetTotalCallCount() == GetTotalHoldCallCount()))
  2402.             {
  2403.                 SetPreviousState(GetCurrentState());
  2404.                 SetCurrentState(CM_HOLD_STATE);
  2405.             }
  2406.             break;
  2408.         default:
  2409.             PRINT_INFORMATION(("n PSHangupSucEvent CM State m/c Corrupted n"));
  2410.         #ifdef __MMI_VOIP__
  2411.             /* call back voip to connect voip */
  2412.             if ((mmi_voip_app_total_call() != 0) && (mmi_voip_app_get_conn_flag() == MMI_VOIP_CALL_CONN_VOIP))
  2413.             {
  2414.                 mmi_voip_app_set_conn_flag(MMI_VOIP_CALL_CONN_NONE);
  2415.                 mmi_voip_entry_ans_to_conn_voip();
  2416.             }
  2417.         #endif /* __MMI_VOIP__ */
  2418.             return CM_CALL_FAILURE;
  2419.     }
  2420. #ifdef __MMI_VOIP__
  2421.     /* call back voip to connect voip */
  2422.     if ((mmi_voip_app_total_call() != 0) && (mmi_voip_app_get_conn_flag() == MMI_VOIP_CALL_CONN_VOIP))
  2423.     {
  2424.         mmi_voip_app_set_conn_flag(MMI_VOIP_CALL_CONN_NONE);
  2425.         mmi_voip_entry_ans_to_conn_voip();
  2426.     }
  2427. #endif /* __MMI_VOIP__ */
  2428.     return CM_CALL_SUCCESS;
  2429. }
  2432. /*****************************************************************************
  2433.  * FUNCTION
  2434.  *  ProcessKBHangupallReqEvent
  2435.  * DESCRIPTION
  2436.  *  This is the function to process Keyboard(Request) Event CM_KB_HANGUPALLREQ.
  2437.  *  
  2438.  *  This Sets the flag CM_HANGUP_REQUESTED to all the calls
  2439.  *  Invoke the protocol function irrespective of the state.
  2440.  *  This is always Invoked in Active state.
  2441.  * PARAMETERS
  2442.  *  MsgStruct               [?]         
  2443.  *  ACTION_RESULT(?)        [OUT]       
  2444.  *  this(?)                 [IN]        Points to NULL as the Hangup is requested on all calls)
  2445.  * RETURNS
  2446.  *  This returns CM_CALL_SUCCESS if success or CM_CALL_FAILURE if failure.
  2447.  *****************************************************************************/
  2448. ACTION_RESULT ProcessKBHangupallReqEvent(void *MsgStruct)
  2449. {
  2450.     /*----------------------------------------------------------------*/
  2451.     /* Local Variables                                                */
  2452.     /*----------------------------------------------------------------*/
  2454.     /*----------------------------------------------------------------*/
  2455.     /* Code Body                                                      */
  2456.     /*----------------------------------------------------------------*/
  2457.     switch (GetCurrentState())
  2458.     {
  2459.         case CM_IDLE_STATE:
  2460.             PRINT_INFORMATION(("n KBHangupallReqEvent CM_IDLE_STATE not handled still n"));
  2461.             break;
  2463.         case CM_INCOMING_STATE:
  2464.             // Start by Julia: Drop call refinement
  2465.             // Drop call refinement is not applicable when waiting call exists
  2466.             SetAllHangupFlag();
  2467.             MakePsHangupallRequest((void*)HangupallReqSucess);
  2468.             break;
  2469.             /* End by Julia */
  2470.         case CM_OUTGOING_STATE:
  2471.         case CM_HOLD_STATE:
  2472.         case CM_ACTIVE_STATE:
  2473.             SetAllHangupFlag();
  2474.             /* Start by Julia: Drop call refinement */
  2475.             SetAllExceptWaitingCallState(CM_DISCONNECTING_STATE);
  2476.             //EntryScr1002ActiveCall();
  2477.             // End by Julia
  2478.             MakePsHangupallRequest((void*)HangupallReqSucess);
  2479.             break;
  2480.         default:
  2481.             PRINT_INFORMATION(("n KBHangupallReqEvent CM State m/c Corrupted n"));
  2482.             return CM_CALL_FAILURE;
  2483.     }
  2484.     return CM_CALL_SUCCESS;
  2485. }
  2488. /*****************************************************************************
  2489.  * FUNCTION
  2490.  *  ProcessPSHangupallSucEvent
  2491.  * DESCRIPTION
  2492.  *  This is the function to process Protocol(Response) Event CM_PS_HANGUPALLSUC.
  2493.  *  
  2494.  *  This resets the CM_HANGUP_REQUESTED flag & change the state of the all calls
  2495.  *  to IDLE.It also changes the state m/c to IDLE.
  2496.  * PARAMETERS
  2497.  *  MsgStruct               [?]         
  2498.  *  ACTION_RESULT(?)        [OUT]       
  2499.  *  this(?)                 [IN]        Is Null as the request CM_KB_HANGUPALLREQ is on all calls)
  2500.  * RETURNS
  2501.  *  This returns CM_CALL_SUCCESS if success or CM_CALL_FAILURE if failure.
  2502.  *****************************************************************************/
  2503. ACTION_RESULT ProcessPSHangupallSucEvent(void *MsgStruct)
  2504. {
  2505.     /*----------------------------------------------------------------*/
  2506.     /* Local Variables                                                */
  2507.     /*----------------------------------------------------------------*/
  2508.     CM_CALL_HANDLE *handle;
  2509.     CALL_STATE state;
  2511.     /*----------------------------------------------------------------*/
  2512.     /* Code Body                                                      */
  2513.     /*----------------------------------------------------------------*/
  2514.     handle = (CM_CALL_HANDLE*) MsgStruct;
  2516.     /* Start by Julia: Drop call refinement */
  2517.     if ((*handle) == -1 || GetMMIStructIndexof(*handle) == -1)
  2518.     {
  2519.         /* call already dropped */
  2520.         PRINT_INFORMATION(("nBad call handle -1 in HangupAllSucn"));
  2521.     #ifdef __MMI_VOIP__
  2522.         /* call back voip to connect voip */
  2523.         if ((mmi_voip_app_total_call() != 0) && (mmi_voip_app_get_conn_flag() == MMI_VOIP_CALL_CONN_VOIP))
  2524.         {
  2525.             mmi_voip_app_set_conn_flag(MMI_VOIP_CALL_CONN_NONE);
  2526.             mmi_voip_entry_ans_to_conn_voip();
  2527.         }
  2528.     #endif /* __MMI_VOIP__ */
  2529.         return CM_CALL_FAILURE;
  2530.     }
  2531.     /* End by Julia */
  2532.     LogCallInfoForCallHistory(*handle);
  2534.     state = GetCallState(*handle);
  2535.     if (state != CM_STATE_UNKNOWN)
  2536.     {
  2537.         /* incoming call will be handled in SetCallState */
  2538.         if (state != CM_INCOMING_STATE)
  2539.         {
  2540.             GetEndTimeAndNotifyEndCallDuration(*handle);
  2541.         }
  2542.         SetCallState((*handle), CM_IDLE_STATE, TRUE);
  2543.     }
  2545.     if (GetTotalActiveCallCount() + GetTotalHoldCallCount() > 0)
  2546.     {
  2547.     #ifdef __MMI_VOIP__
  2548.         /* call back voip to connect voip */
  2549.         if ((mmi_voip_app_total_call() != 0) && (mmi_voip_app_get_conn_flag() == MMI_VOIP_CALL_CONN_VOIP))
  2550.         {
  2551.             mmi_voip_app_set_conn_flag(MMI_VOIP_CALL_CONN_NONE);
  2552.             mmi_voip_entry_ans_to_conn_voip();
  2553.         }
  2554.     #endif /* __MMI_VOIP__ */
  2555.         return CM_CALL_SUCCESS;
  2556.     }
  2558.     switch (GetCurrentState())
  2559.     {
  2560.         case CM_IDLE_STATE:
  2561.             PRINT_INFORMATION(("n PSHangupallSucEvent CM_IDLE_STATE not handled still n"));
  2562.             break;
  2564.         case CM_INCOMING_STATE:
  2565.         case CM_OUTGOING_STATE:
  2566.         case CM_HOLD_STATE:
  2567.         case CM_ACTIVE_STATE:
  2568.             if (GetTotalCallCount() == 0)
  2569.             {
  2570.                 SetPreviousState(GetCurrentState());
  2571.                 SetCurrentState(CM_IDLE_STATE);
  2572.             }
  2573.             else if (state == CM_INCOMING_STATE || state == CM_OUTGOING_STATE)
  2574.             {
  2575.                 SetCurrentState(GetPreviousState());
  2576.                 SetPreviousState(state);
  2577.             }
  2578.             break;
  2579.         default:
  2580.             PRINT_INFORMATION(("n PSHangupallSucEvent CM State m/c Corrupted n"));
  2581.         #ifdef __MMI_VOIP__
  2582.             /* call back voip to connect voip */
  2583.             if ((mmi_voip_app_total_call() != 0) && (mmi_voip_app_get_conn_flag() == MMI_VOIP_CALL_CONN_VOIP))
  2584.             {
  2585.                 mmi_voip_app_set_conn_flag(MMI_VOIP_CALL_CONN_NONE);
  2586.                 mmi_voip_entry_ans_to_conn_voip();
  2587.             }
  2588.         #endif /* __MMI_VOIP__ */
  2589.             return CM_CALL_FAILURE;
  2590.     }
  2591. #ifdef __MMI_VOIP__
  2592.     /* call back voip to connect voip */
  2593.     if ((mmi_voip_app_total_call() != 0) && (mmi_voip_app_get_conn_flag() == MMI_VOIP_CALL_CONN_VOIP))
  2594.     {
  2595.         mmi_voip_app_set_conn_flag(MMI_VOIP_CALL_CONN_NONE);
  2596.         mmi_voip_entry_ans_to_conn_voip();
  2597.     }
  2598. #endif /* __MMI_VOIP__ */
  2599.     return CM_CALL_SUCCESS;
  2600. }
  2603. /*****************************************************************************
  2604.  * FUNCTION
  2605.  *  ProcessKBHangupallActReqEvent
  2606.  * DESCRIPTION
  2607.  *  This is the function to process Keyboard(Request) Event CM_KB_HANGUPALLACTREQ.
  2608.  *  
  2609.  *  This Sets the flag CM_HANGUP_REQUESTED to all the Active calls
  2610.  *  Invoke the protocol function irrespective of the state.
  2611.  *  This is always Invoked in Active state as active call take precedence over held call.
  2612.  * PARAMETERS
  2613.  *  MsgStruct               [?]         
  2614.  *  ACTION_RESULT(?)        [OUT]       
  2615.  *  this(?)                 [IN]        Points to NULL as the Hangup is requested on all Active calls)
  2616.  * RETURNS
  2617.  *  This returns CM_CALL_SUCCESS if success or CM_CALL_FAILURE if failure.
  2618.  *****************************************************************************/
  2619. ACTION_RESULT ProcessKBHangupallActReqEvent(void *MsgStruct)
  2620. {
  2621.     /*----------------------------------------------------------------*/
  2622.     /* Local Variables                                                */
  2623.     /*----------------------------------------------------------------*/
  2625.     /*----------------------------------------------------------------*/
  2626.     /* Code Body                                                      */
  2627.     /*----------------------------------------------------------------*/
  2628.     switch (GetCurrentState())
  2629.     {
  2630.         case CM_IDLE_STATE:
  2631.             PRINT_INFORMATION(("n KBHangupallActReqEvent CM_IDLE_STATE not handled still n"));
  2632.             break;
  2634.         case CM_OUTGOING_STATE:
  2635.             PRINT_INFORMATION(("n KBHangupallActReqEvent CM_OUTGOING_STATE not handled still n"));
  2636.             break;
  2638.         case CM_INCOMING_STATE:
  2639.             // Start by Julia: Drop call refinement
  2640.             // Drop call refinement is not applicable when waiting call exists
  2641.             SetAllActHangupFlag();
  2642.             MakePsHangupallActiveRequest((void*)HangupallActReqSucess);
  2643.             break;
  2644.             /* End by Julia */
  2645.         case CM_ACTIVE_STATE:
  2646.             SetAllActHangupFlag();
  2647.             /* Start by Julia: Drop call refinement */
  2648.             SetAllActiveCallState(CM_DISCONNECTING_STATE);
  2649.             //EntryScr1002ActiveCall();
  2650.             // End by Julia
  2651.             MakePsHangupallActiveRequest((void*)HangupallActReqSucess);
  2652.             break;
  2654.         case CM_HOLD_STATE:
  2655.             PRINT_INFORMATION(("n KBHangupallActReqEvent CM_HOLD_STATE not handled still n"));
  2656.             break;
  2658.         default:
  2659.             PRINT_INFORMATION(("n KBHangupallActReqEvent CM State m/c Corrupted n"));
  2660.             return CM_CALL_FAILURE;
  2661.     }
  2662.     return CM_CALL_SUCCESS;
  2663. }
  2666. /*****************************************************************************
  2667.  * FUNCTION
  2668.  *  ProcessPSHangupallActSucEvent
  2669.  * DESCRIPTION
  2670.  *  This is the function to process Protocol(Response) Event CM_PS_HANGUPALLACTSUC.
  2671.  *  
  2672.  *  This resets the CM_HANGUP_REQUESTED flag & change the state of the all Active calls
  2673.  *  to IDLE.If necessary,It also changes the state of the state m/c.
  2674.  * PARAMETERS
  2675.  *  MsgStruct               [?]         
  2676.  *  ACTION_RESULT(?)        [OUT]       
  2677.  *  this(?)                 [IN]        Is Null as the request CM_KB_HANGUPALLACTREQ is on all Active calls)
  2678.  * RETURNS
  2679.  *  This returns CM_CALL_SUCCESS if success or CM_CALL_FAILURE if failure.
  2680.  *****************************************************************************/
  2681. ACTION_RESULT ProcessPSHangupallActSucEvent(void *MsgStruct)
  2682. {
  2683.     /*----------------------------------------------------------------*/
  2684.     /* Local Variables                                                */
  2685.     /*----------------------------------------------------------------*/
  2686.     CM_CALL_HANDLE *handle;
  2688.     /*----------------------------------------------------------------*/
  2689.     /* Code Body                                                      */
  2690.     /*----------------------------------------------------------------*/
  2691.     PRINT_INFORMATION(("n *** In ProcessPSHangupallActSucEventn"));
  2693.     handle = (CM_CALL_HANDLE*) MsgStruct;
  2695.     /* Start by Julia: Drop call refinement */
  2696.     if ((*handle) == -1)
  2697.     {
  2698.         PRINT_INFORMATION(("nBad call handle -1 in HangupAllActSucn"));
  2699.         return CM_CALL_FAILURE;
  2700.     }
  2701.     /* End by Julia */
  2702.     LogCallInfoForCallHistory(*handle);
  2703.     GetEndTimeAndNotifyEndCallDuration(*handle);
  2704.     SetCallState(*handle, CM_IDLE_STATE, TRUE);
  2705.     if (GetTotalActiveCallCount() >= 1)
  2706.     {
  2707.         return CM_CALL_SUCCESS;
  2708.     }
  2709.     switch (GetCurrentState())
  2710.     {
  2711.         case CM_IDLE_STATE:
  2712.             PRINT_INFORMATION(("n PSHangupallActSucEvent CM_IDLE_STATE not handled still n"));
  2713.             break;
  2715.         case CM_OUTGOING_STATE:
  2716.             PRINT_INFORMATION(("n PSHangupallActSucEvent CM_OUTGOING_STATE not handled still n"));
  2717.             break;
  2719.         case CM_INCOMING_STATE:
  2720.         case CM_ACTIVE_STATE:
  2721.             MakeAllActHangup();
  2723.             if (GetTotalCallCount() == 0)
  2724.             {
  2725.                 SetPreviousState(GetCurrentState());
  2726.                 SetCurrentState(CM_IDLE_STATE);
  2727.             }
  2728.             break;
  2730.         case CM_HOLD_STATE:
  2731.             PRINT_INFORMATION(("n PSHangupallActSucEvent CM_HOLD_STATE not handled still n"));
  2732.             break;
  2734.         default:
  2735.             PRINT_INFORMATION(("n Illegal state to be in  n"));
  2736.             return CM_CALL_FAILURE;
  2737.     }
  2738.     return CM_CALL_SUCCESS;
  2739. }
  2742. /*****************************************************************************
  2743.  * FUNCTION
  2744.  *  ProcessKBHangupallHldReqEvent
  2745.  * DESCRIPTION
  2746.  *  This is the function to process Keyboard(Request) Event CM_KB_HANGUPALLHLDREQ.
  2747.  *  
  2748.  *  This Sets the flag CM_HANGUP_REQUESTED to all the Hold/Held calls
  2749.  *  Invoke the protocol function irrespective of the state.
  2750.  *  This is Invoked in Active or Hold state.
  2751.  * PARAMETERS
  2752.  *  MsgStruct               [?]         
  2753.  *  ACTION_RESULT(?)        [OUT]       
  2754.  *  this(?)                 [IN]        Points to NULL as the Hangup is requested on all Hold State calls)
  2755.  * RETURNS
  2756.  *  This returns CM_CALL_SUCCESS if success or CM_CALL_FAILURE if failure.
  2757.  *****************************************************************************/
  2758. ACTION_RESULT ProcessKBHangupallHldReqEvent(void *MsgStruct)
  2759. {
  2760.     /*----------------------------------------------------------------*/
  2761.     /* Local Variables                                                */
  2762.     /*----------------------------------------------------------------*/
  2764.     /*----------------------------------------------------------------*/
  2765.     /* Code Body                                                      */
  2766.     /*----------------------------------------------------------------*/
  2767.     SetAllHldHangupFlag();
  2768.     // Start by Julia: Drop call refinement
  2769.     // Drop call refinement is not applicable when waiting call exists
  2770.     if (GetCurrentState() != CM_INCOMING_STATE)
  2771.     {
  2772.         SetAllHeldCallState(CM_DISCONNECTING_STATE);
  2773.         /* EntryScr1002ActiveCall(); */
  2774.     }
  2775.     /* End by Julia */
  2776.     MakePsSendRelHeld((void*)HangupallHldReqSucess);
  2777.     return CM_CALL_SUCCESS;
  2778. }
  2781. /*****************************************************************************
  2782.  * FUNCTION
  2783.  *  ProcessPSHangupallHldSucEvent
  2784.  * DESCRIPTION
  2785.  *  This is the function to process Protocol(Response) Event CM_PS_HANGUPALLHLDSUC.
  2786.  *  
  2787.  *  This resets the CM_HANGUP_REQUESTED flag & change the state of the all held calls
  2788.  *  to IDLE.If necessary,It also changes the state of the state m/c.
  2789.  * PARAMETERS
  2790.  *  MsgStruct               [?]         
  2791.  *  ACTION_RESULT(?)        [OUT]       
  2792.  *  this(?)                 [IN]        Is Null as the request CM_KB_HANGUPALLHLDREQ is on all Held/Hold state calls)
  2793.  * RETURNS
  2794.  *  This returns CM_CALL_SUCCESS if success or CM_CALL_FAILURE if failure.
  2795.  *****************************************************************************/
  2796. ACTION_RESULT ProcessPSHangupallHldSucEvent(void *MsgStruct)
  2797. {
  2798.     /*----------------------------------------------------------------*/
  2799.     /* Local Variables                                                */
  2800.     /*----------------------------------------------------------------*/
  2801.     CM_CALL_HANDLE *handle;
  2803.     /*----------------------------------------------------------------*/
  2804.     /* Code Body                                                      */
  2805.     /*----------------------------------------------------------------*/
  2806.     handle = (CM_CALL_HANDLE*) MsgStruct;
  2808.     /* Start by Julia: Drop call refinement */
  2809.     if ((*handle) == -1)
  2810.     {
  2811.         PRINT_INFORMATION(("nBad call handle -1 in HangupAllHldSucn"));
  2812.         return CM_CALL_FAILURE;
  2813.     }
  2814.     /* End by Julia */
  2815.     LogCallInfoForCallHistory(*handle);
  2816.     GetEndTimeAndNotifyEndCallDuration(*handle);
  2818.     SetCallState((*handle), CM_IDLE_STATE, TRUE);
  2820.     if (GetTotalHoldCallCount() > 0)
  2821.     {
  2822.         return CM_CALL_SUCCESS;
  2823.     }
  2825.     switch (GetCurrentState())
  2826.     {
  2827.         case CM_IDLE_STATE:
  2828.             PRINT_INFORMATION(("n PSHangupallHldSucEvent CM_IDLE_STATE not handled still n"));
  2829.             break;
  2831.         case CM_OUTGOING_STATE:
  2832.             PRINT_INFORMATION(("n PSHangupallHldSucEvent CM_OUTGOING_STATE not handled still n"));
  2833.             break;
  2835.         case CM_INCOMING_STATE:
  2836.             PRINT_INFORMATION(("n PSHangupallHldSucEvent CM_INCOMING_STATE not handled still n"));
  2837.             break;
  2839.         case CM_ACTIVE_STATE:
  2840.         case CM_HOLD_STATE:
  2841.             if (GetTotalCallCount() == 0)
  2842.             {
  2843.                 SetPreviousState(GetCurrentState());
  2844.                 SetCurrentState(CM_IDLE_STATE);
  2845.             }
  2846.             break;
  2848.         default:
  2849.             PRINT_INFORMATION(("n PSHangupallHldSucEvent CM State m/c Corrupted n"));
  2850.             return CM_CALL_FAILURE;
  2851.     }
  2852.     return CM_CALL_SUCCESS;
  2853. }
  2856. /*****************************************************************************
  2857.  * FUNCTION
  2858.  *  ProcessKBHoldReqEvent
  2859.  * DESCRIPTION
  2860.  *  This is the function to process Keyboard(Request) Event CM_KB_HOLDREQ.
  2861.  *  
  2862.  *  This Sets the flag CM_HOLD_REQUESTED to all the active call
  2863.  *  Invoke the protocol function irrespective of the state.
  2864.  *  The chances of this being invoked in Idle or Hold  state is very less.
  2865.  * PARAMETERS
  2866.  *  MsgStruct               [?]         
  2867.  *  ACTION_RESULT(?)        [OUT]       
  2868.  *  this(?)                 [IN]        Points to NULL as the hold is request on all active calls)
  2869.  * RETURNS
  2870.  *  This returns CM_CALL_SUCCESS if success or CM_CALL_FAILURE if failure.
  2871.  *****************************************************************************/
  2872. ACTION_RESULT ProcessKBHoldReqEvent(void *MsgStruct)
  2873. {
  2874.     /*----------------------------------------------------------------*/
  2875.     /* Local Variables                                                */
  2876.     /*----------------------------------------------------------------*/
  2877. U8 flag;
  2879.     /*----------------------------------------------------------------*/
  2880.     /* Code Body                                                      */
  2881.     /*----------------------------------------------------------------*/
  2882.     if (GetChldReqSent() != CM_ACTION_NONE)
  2883.     {
  2884.         return CM_CALL_FAILURE;
  2885.     }
  2887.     flag = GetAllCallFlags();
  2888.     if (((flag & CM_SWAP_REQUESTED) != 0) || 
  2889.      ((flag & CM_CONF_REQUESTED) != 0) ||
  2890.      ((flag & CM_ECT_REQUESTED) != 0))
  2891.     {
  2892.         return CM_CALL_FAILURE;
  2893.     }
  2895.     switch (GetCurrentState())
  2896.     {
  2897.         case CM_IDLE_STATE:
  2898.             PRINT_INFORMATION(("n KBHoldReqEvent CM_IDLE_STATE not handled still n"));
  2899.             break;
  2901.         case CM_OUTGOING_STATE:
  2902.             PRINT_INFORMATION(("n KBHoldReqEvent CM_OUTGOING_STATE not handled still n"));
  2903.             break;
  2905.         case CM_INCOMING_STATE:
  2906.             PRINT_INFORMATION(("n KBHoldReqEvent CM_INCOMING_STATE not handled still n"));
  2907.             break;
  2909.         case CM_ACTIVE_STATE:
  2910.             SetHoldFlag();
  2911.             MakePsActiveHold((void*)HoldReqSucess);
  2912.             break;
  2914.         case CM_HOLD_STATE:
  2915.             PRINT_INFORMATION(("n KBHoldReqEvent CM_HOLD_STATE not handled still n"));
  2916.             break;
  2918.         default:
  2919.             PRINT_INFORMATION(("n KBHoldReqEvent CM State m/c Corrupted n"));
  2920.             return CM_CALL_FAILURE;
  2921.     }
  2923.     return CM_CALL_SUCCESS;
  2924. }
  2927. /*****************************************************************************
  2928.  * FUNCTION
  2929.  *  ProcessPSHoldSucEvent
  2930.  * DESCRIPTION
  2931.  *  This is the function to process Protocol(Response) Event CM_PS_HOLDSUC.
  2932.  *  
  2933.  *  This resets the CM_HOLD_REQUESTED flag & change the state of the call from
  2934.  *  ACTIVE to HOLD if necessary it also changes the state of the State m/c.
  2935.  * PARAMETERS
  2936.  *  MsgStruct               [?]         
  2937.  *  ACTION_RESULT(?)        [OUT]       
  2938.  *  this(?)                 [IN]        Is Null as the request CM_KB_HOLDREQ is on all active call)
  2939.  * RETURNS
  2940.  *  This returns CM_CALL_SUCCESS if success or CM_CALL_FAILURE if failure.
  2941.  *****************************************************************************/
  2942. ACTION_RESULT ProcessPSHoldSucEvent(void *MsgStruct)
  2943. {
  2944.     /*----------------------------------------------------------------*/
  2945.     /* Local Variables                                                */
  2946.     /*----------------------------------------------------------------*/
  2948.     /*----------------------------------------------------------------*/
  2949.     /* Code Body                                                      */
  2950.     /*----------------------------------------------------------------*/
  2951.     switch (GetCurrentState())
  2952.     {
  2953.         case CM_IDLE_STATE:
  2954.             PRINT_INFORMATION(("n PSHoldSucEvent CM_IDLE_STATE not handled still n"));
  2955.             break;
  2957.         case CM_OUTGOING_STATE:
  2958.             PRINT_INFORMATION(("n PSHoldSucEvent CM_OUTGOING_STATE not handled still n"));
  2959.             break;
  2961.         case CM_INCOMING_STATE:
  2962.             PRINT_INFORMATION(("n PSHoldSucEvent CM_INCOMING_STATE n"));
  2963.             MakeHold();
  2964.             EntryScr1005NotifyHoldSucess();
  2965.             SyncCallList();
  2966.             break;
  2968.         case CM_ACTIVE_STATE:
  2969.             PRINT_INFORMATION(("n PSHoldSucEvent CM_ACTIVE_STATE n"));
  2970.             MakeHold();
  2971.             EntryScr1005NotifyHoldSucess();
  2972.             break;
  2974.         case CM_HOLD_STATE:
  2975.             PRINT_INFORMATION(("n HoldSucEvent CM_HOLD_STATE not handled still n"));
  2976.             break;
  2978.         default:
  2979.             PRINT_INFORMATION(("n PSHoldSucEvent CM State m/c Corrupted n"));
  2980.             return CM_CALL_FAILURE;
  2981.     }
  2982.     return CM_CALL_SUCCESS;
  2983. }