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

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

MTK

开发平台：

C/C++

OutgoingCallHelper.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.  *   OutgoingCallHelper.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.  * Register callback function fop dialing icon
  344.  *
  345.  *******************************************************************************/
  347. /**
  348.  * Copyright Notice
  349.  * ?2002 - 2003, Pixtel Communications, Inc., 1489 43rd Ave. W.,
  350.  * Vancouver, B.C. V6M 4K8 Canada. All Rights Reserved.
  351.  *  (It is illegal to remove this copyright notice from this software or any
  352.  *  portion of it)
  353.  */
  355. /**************************************************************
  357.    FILENAME : OutgoingCallHelper.c
  359.    PURPOSE     : Call Management application
  361.    REMARKS     : nil
  363.    AUTHOR      : Subramanya BG
  365.    DATE     : Nov 12,02
  367. **************************************************************/
  368. #include "stdC.h"
  369. #include "MMI_Features.h"
  370. #include "L4Dr.h"
  371. #include "L4Dr1.h"
  372. #include "PixtelDataTypes.h"
  373. #include "GlobalConstants.h"
  374. #include "GlobalScrEnum.h"
  375. #include "DebugInitDef.h"
  376. #include "ProtocolEvents.h"
  377. #include "EventsGprot.h"
  378. #include "HistoryGprot.h"
  379. #include "CommonScreens.h"
  380. #include "wgui.h"
  381. #include "Wgui_status_icons.h"
  382. #include "wgui_categories_inputs.h"
  383. #include "wgui_categories_CM.h"
  384. #include "GlobalDefs.h"
  385. #include "TimerEvents.h"
  387. #include "BootUp.h"
  388. #include "PowerOnChargerProt.h"
  389. #include "PhonebookDef.h"
  390. #include "PhoneBookTypes.h"
  391. #include "PhoneBookGprot.h"
  392. #include "CallSetUpEnum.h"
  393. #include "SimDetectionGexdcl.h"
  394. #include "SimDetectionGprot.h"
  395. #include "AlarmFrameworkProt.h"
  396. #include "DateTimeGprot.h"
  398. #include "CallmanagementIdDef.h"
  399. #include "CallManagementStruct.h"
  400. #include "CallStructureManagementProt.h"
  401. #include "CmErrorTypes.h"
  402. #include "CmErrorHandlersProt.h"
  403. #include "CommonStubsProt.h"
  404. #include "HistoryHelperProt.h"
  405. #include "PsCallHelperDef.h"
  406. #include "mmiapi_struct.h"
  407. #include "PsCallHelperGprot.h"
  408. #include "RedialHelperGProt.h"
  409. #include "CallManagementGprot.h"
  410. #include "IncomingCallManagementProt.h"
  411. #include "OutgoingCallManagementProt.h"
  413. #include "CallsGProts.h"
  415. #include "OutgoingCallHelperGProt.h"
  416. #include "OutgoingCallHelperProt.h"
  417. #include "gpioInc.h"
  419. #ifdef __MMI_VOIP__
  420. #include "VoIPGProt.h"
  421. #endif
  423. #if defined(__MMI_WLAN_FEATURES__) && defined(__MMI_VOIP__)
  424. #include "NetworkSetupDefs.h"
  425. #endif
  427. #if defined(__MMI_BG_SOUND_EFFECT__)
  428. #include "BGSoundGProt.h"
  429. #endif 
  431. #ifdef __MMI_BT_PROFILE__
  432. #include "mdi_datatype.h"
  433. #include "mdi_audio.h"
  434. void mmi_profiles_bt_call_start_callback(void);
  435. #endif /* __MMI_BT_PROFILE__ */ 
  437. #if defined (JATAAYU_SUPPORT) && defined (WAP_SUPPORT)
  438. #include "ddl.h"
  439. #include "jcutils.h"
  440. #include "jcerror.h"
  441. #include "jdd_tapi.h"
  442. #endif
  444. static CM_CALL_HANDLE gMyhandle;
  446. /* static U16 curKeyCode, curKeyType; */
  447. static pBOOL gCheckDialIndEndOutgoing = FALSE;
  449. S8 DTMFPadCallBuffer[MAX_DIGITS_USSD];
  450. S8 UnicodeDTMFPadCallBuffer[MAX_DIGITS_USSD * ENCODING_LENGTH];
  451. PU8 gCallDeflectNumber;
  453. extern U16 gtmpOutgoingIndex;
  454. extern void SSCHandleIMEI(void);
  456. const U16 CMIdleScreenDigits[MAX_CM_SCREEN_DIGITS] = 
  457. {
  458.     KEY_0, KEY_1, KEY_2, KEY_3,
  459.     KEY_4, KEY_5, KEY_6, KEY_7,
  460.     KEY_8, KEY_9, KEY_STAR,
  461.     KEY_POUND
  462. };
  465. /*****************************************************************************
  466.  * FUNCTION
  467.  *  MakeCallEx
  468.  * DESCRIPTION
  469.  *  Wrapper which checks to see if the call to be made is
  470.  *  O/G or USSD
  471.  *  
  472.  *  This function is exported to others applications
  473.  * PARAMETERS
  474.  *  strNumber       [IN]        
  475.  *  pre_check       [IN]        
  476.  *  Number(?)       [IN]        Which needs to be sent to network
  477.  * RETURNS
  478.  *  void
  479.  *****************************************************************************/
  480. void MakeCallEx(PS8 strNumber, BOOL pre_check)
  481. {
  482.     /*----------------------------------------------------------------*/
  483.     /* Local Variables                                                */
  484.     /*----------------------------------------------------------------*/
  486.     /*----------------------------------------------------------------*/
  487.     /* Code Body                                                      */
  488.     /*----------------------------------------------------------------*/
  489.     /* check low battery */
  490.     if (!CHECK_MO_ALLOW())
  491.     {
  492.         ChgrPlayLowBatTone();
  493.         BatteryIndicationPopup(STR_LOW_BATTERY_MT_PROHIBIT);
  494.         return;
  495.     }
  496. #ifdef __MMI_VOIP__
  497.     /* cannot dial gsm call when voip call exists */
  498.     if (mmi_voip_app_total_call() != 0)
  499.     {
  500.         ShowCallManagementErrorMessage(ERR_REQ_FACILITY_UNAVAIL);
  501.         return;
  502.     }
  503. #endif /* __MMI_VOIP__ */
  505.     if (IS_LOW_BATTERY())
  506.     {
  507.         ChgrPlayLowBatTone();
  508.         if (g_charbat_context.LowBatteryTxProhibitFlag)
  509.         {
  510.             SET_LOW_BATTERY_ALARM_THRESHOLD(LBAT_TALK_DURCNT_PROHIBIT);
  511.         }
  512.         else
  513.         {
  514.             SET_LOW_BATTERY_ALARM_THRESHOLD(LBAT_TALK_DURCNT_NORMAL);
  515.         }
  516.     }
  518.     SetNoSave();
  520.     if (!GetDialedDigitCalledFlag())
  521.     {
  522.         ClearDtmfBuf();
  523.         FillDtmfBuff((PU8) strNumber);
  524.     }
  525.     else
  526.     {
  527.         SetDialedDigitCalledFlag(FALSE);
  528.     }
  530.     if (!pre_check)
  531.     {
  532.         if (NULL == strNumber)
  533.         {
  534.             SetCallDeflectFlag(FALSE);
  535.             ShowCallManagementErrorMessage(ERR_INVALID_NUMBER_FORMAT);
  536.             return;
  537.         }
  538.         else if (0 == *strNumber)
  539.         {
  540.             SetCallDeflectFlag(FALSE);
  541.             ShowCallManagementErrorMessage(ERR_INVALID_NUMBER_FORMAT);
  542.             return;
  543.         }
  545. if (!CheckValidEmergencyNo1(strNumber))
  546. {
  547.         if (UCS2StrFirstPositionSearch(strNumber) == FALSE)
  548.         {
  549.             SetCallDeflectFlag(FALSE);
  550.             ShowCallManagementErrorMessage(ERR_INVALID_NUMBER_FORMAT);
  551.             return;
  552.         }
  553.         if (UCS2StrNoFirstPositionSearch(strNumber, 'p') == FALSE)
  554.         {
  555.             SetCallDeflectFlag(FALSE);
  556.             ShowCallManagementErrorMessage(ERR_INVALID_NUMBER_FORMAT);
  557.             return;
  558.         }
  559.         if (UCS2StrNoFirstPositionSearch(strNumber, 'w') == FALSE)
  560.         {
  561.             SetCallDeflectFlag(FALSE);
  562.             ShowCallManagementErrorMessage(ERR_INVALID_NUMBER_FORMAT);
  563.             return;
  564.         }
  565.         }
  566.     }
  568.     CheckShortCutOrCall();
  569. }
  572. /*****************************************************************************
  573.  * FUNCTION
  574.  *  MakeCall
  575.  * DESCRIPTION
  576.  *  Check if the background sound is turn on
  577.  *  
  578.  *  This function is exported to others applications
  579.  * PARAMETERS
  580.  *  strNumber       [IN]        
  581.  *  Number(?)       [IN]        Which needs to be sent to network
  582.  * RETURNS
  583.  *  void
  584.  *****************************************************************************/
  585. void MakeCall(PS8 strNumber)
  586. {
  587. #if defined(__MMI_BG_SOUND_EFFECT__)
  588.     /*----------------------------------------------------------------*/
  589.     /* Local Variables                                                */
  590.     /*----------------------------------------------------------------*/
  591.     U16 scr_id;
  593.     /*----------------------------------------------------------------*/
  594.     /* Code Body                                                      */
  595.     /*----------------------------------------------------------------*/
  596. #if defined(__MMI_WLAN_FEATURES__) && defined(__MMI_VOIP__)
  597.     if (mmi_netset_get_active_preferred_mode() == 1 /*&& ref_prefer_mode == MMI_TRUE*/)
  598.     {
  599.         /* preferred mode = WLAN only */
  600.         DisplayPopup(
  601.             (PU8)GetString(STR_GLOBAL_UNFINISHED),
  602.             IMG_GLOBAL_UNFINISHED,
  603.             1,
  604.             CS_NOTIFYDURATION,
  605.             (U8)ERROR_TONE);
  606.         mmi_phb_call_set_dial_from_list(MMI_PHB_NONE);  /* reset dial from phonebook flag */
  607.         CHISTSetDialFromCallLogFlag(0);                 /* reset dial from call history flag */
  608.         return;
  609.     }
  610. #endif /* defined(__MMI_WLAN_FEATURES__) && defined(__MMI_VOIP__) */
  612.     /* Don't enter background sound in the call setup screen */
  613.     scr_id = GetActiveScreenId();
  614.     SetNoSave();
  616.     /* Do check in advance to avoid some screen problem. */
  617.     if (!(scr_id >= SCR_ID_CALLSET_BARRING_MAIN && scr_id <= SCR_SETTING_BLACK_LIST_NUM) &&
  618.         (strNumber != NULL) &&
  619.         (*strNumber != 0) &&
  620. ( ( CheckValidEmergencyNo1(strNumber) ) ||
  621.         (UCS2StrFirstPositionSearch(strNumber) == TRUE) &&
  622.         (UCS2StrNoFirstPositionSearch(strNumber, 'p') == TRUE) &&
  623.         (UCS2StrNoFirstPositionSearch(strNumber, 'w') == TRUE) ) &&
  624.         (CHECK_MO_ALLOW()) &&
  625.         (mmi_bgsnd_mo_call_check_last_char(strNumber, '#') == MMI_FALSE))  /* Not SS string */
  626.     {
  627.         /* Already check the number correctness, no need to check in MakeCallEx() again */
  628.         if (mmi_bgsnd_mo_call_use_effect(strNumber) == FALSE)
  629.         {
  630.             MakeCallEx(strNumber, TRUE);
  631.         }
  632.     }
  633.     else
  634.     {
  635.         /* Check number correctness fail, let it check again and popup error message in the MakeCallEx() */
  636. #if defined(__MMI_WLAN_FEATURES__) && defined(__MMI_VOIP__)
  637.     if (mmi_netset_get_active_preferred_mode() == 1 /*&& ref_prefer_mode == MMI_TRUE*/)
  638.     {
  639.         /* preferred mode = WLAN only */
  640.         DisplayPopup(
  641.             (PU8) GetString(STR_GLOBAL_UNFINISHED),
  642.             IMG_GLOBAL_UNFINISHED,
  643.             1,
  644.             CS_NOTIFYDURATION,
  645.             (U8) ERROR_TONE);
  646.         mmi_phb_call_set_dial_from_list(MMI_PHB_NONE);  /* reset dial from phonebook flag */
  647.         CHISTSetDialFromCallLogFlag(0);                 /* reset dial from call history flag */
  648.         return;
  649.     }
  650. #endif /* defined(__MMI_WLAN_FEATURES__) && defined(__MMI_VOIP__) */
  652.         MakeCallEx(strNumber, FALSE);
  653.     }
  655. #else /* defined(__MMI_BG_SOUND_EFFECT__) */ 
  657.     MakeCallEx(strNumber, FALSE);
  659. #endif /* defined(__MMI_BG_SOUND_EFFECT__) */ 
  660. }
  663. /*****************************************************************************
  664.  * FUNCTION
  665.  *  CheckShortCutOrCall
  666.  * DESCRIPTION
  667.  *  Helper function to check if the key is shortcut or not
  668.  *  if not it makes a call
  669.  * PARAMETERS
  670.  *  void
  671.  * RETURNS
  672.  *  void
  673.  *****************************************************************************/
  674. void CheckShortCutOrCall(void)
  675. {
  676.     /*----------------------------------------------------------------*/
  677.     /* Local Variables                                                */
  678.     /*----------------------------------------------------------------*/
  679.     PU8 dtmfBuf;
  681.     /*----------------------------------------------------------------*/
  682.     /* Code Body                                                      */
  683.     /*----------------------------------------------------------------*/
  684.     SetNoSave();
  685.     dtmfBuf = GetDtmfBuffer();
  687.     if (GetCallDeflectFlag() == FALSE)
  688.     {
  689.         if (IsStandardGsmSS(dtmfBuf))
  690.         {
  691.             return;
  692.         }
  693.     }
  695.     if (GetCallDeflectFlag() == TRUE)
  696.     {
  697.         PRINT_INFORMATION(("XXX Call Deflectionn"));
  698.         SetCallDeflectFlag(FALSE);
  699.         OutgoingProcessCMEvent(CM_KB_CALL_DEFLECT_REQ, dtmfBuf);
  700.         /* return; */
  701.     }
  702.     else if (IsSimControlProcedure(dtmfBuf) == TRUE)
  703.     {
  704.         PRINT_INFORMATION(("XXX Sim Specifc Controln"));
  705.         return;
  706.     }
  707.     else if (IsManufactuerSpecific(dtmfBuf) == TRUE)
  708.     {
  709.         PRINT_INFORMATION(("XXX Manufacture Specific Control n"));
  710.         return;
  711.     }
  712.     else if (isHashString(dtmfBuf))
  713.     {
  714.         MakeMyCall((PS8) dtmfBuf);
  715.     }
  716.     else if (isShortString(dtmfBuf))
  717.     {
  718.         MakeMyCall((PS8) dtmfBuf);
  719.     }
  720.     else    /* if (AllowMoreCalls()) */
  721.     {
  722.         MakeMyCall((PS8) dtmfBuf);
  723.     }
  724.     /* else
  725.        {
  726.        ShowCallManagementErrorMessage(ERR_CSMCC_CMD_NOT_ALLOW);
  727.        } */
  729.     ClearDtmfBuf();
  730. }
  733. /*****************************************************************************
  734.  * FUNCTION
  735.  *  MakeMyCall
  736.  * DESCRIPTION
  737.  *  Helper function to make a outgoingcall of a given number.
  738.  *  
  739.  *  This converts the number to OUTGOING_CALL structure which is necessary for State m/c.
  740.  * PARAMETERS
  741.  *  strNumber       [IN]        
  742.  *  Number(?)       [IN]        Which needs to make the outgoing call.
  743.  * RETURNS
  744.  *  void
  745.  *****************************************************************************/
  746. void MakeMyCall(PS8 strNumber)
  747. {
  748.     /*----------------------------------------------------------------*/
  749.     /* Local Variables                                                */
  750.     /*----------------------------------------------------------------*/
  751.     OUTGOING_CALL outCall;
  753.     /*----------------------------------------------------------------*/
  754.     /* Code Body                                                      */
  755.     /*----------------------------------------------------------------*/
  756.     memset(&outCall, 0, sizeof(OUTGOING_CALL));
  757.     if ((strlen((void*)strNumber) * ENCODING_LENGTH) > MAX_CM_NUMBER)
  758.     {
  759.         PRINT_INFORMATION(("XXX Number too long XXX n"));
  760.         ShowCallManagementErrorMessage(ERR_INVALID_NUMBER_FORMAT);
  761.         return;
  762.     }
  763.     pfnUnicodeStrcpy((void*)outCall.Number, (void*)UnicodeDTMFPadCallBuffer);
  764.     MakeOutgoingcall(outCall);
  765. }
  768. /*****************************************************************************
  769.  * FUNCTION
  770.  *  MakeOutgoingcall
  771.  * DESCRIPTION
  772.  *  Helper function to generate Keybrd Event CM_KB_OUTGOINGCALL with the OUTGOING_CALL structure.
  773.  *  
  774.  *  This invokes the function to process the CM_KB_OUTGOINGCALL event in the state m/c.
  775.  * PARAMETERS
  776.  *  MsgStruct           [IN]        
  777.  *  structure(?)        [IN]        Contains the calling number and name if present corresponding to that number.
  778.  * RETURNS
  779.  *  void
  780.  *****************************************************************************/
  781. void MakeOutgoingcall(OUTGOING_CALL MsgStruct)
  782. {
  783.     /*----------------------------------------------------------------*/
  784.     /* Local Variables                                                */
  785.     /*----------------------------------------------------------------*/
  787.     /*----------------------------------------------------------------*/
  788.     /* Code Body                                                      */
  789.     /*----------------------------------------------------------------*/
  790.     OutgoingProcessCMEvent(CM_KB_OUTGOINGCALL, &MsgStruct);
  791. }
  794. /*****************************************************************************
  795.  * FUNCTION
  796.  *  IsStandardGsmSS
  797.  * DESCRIPTION
  798.  *  Helper function for interpreting user code
  799.  * PARAMETERS
  800.  *  dtmfBuf         [IN]        
  801.  *  true(?)         [OUT]       Or false on the basis of interepretaion of SS
  802.  *  buffer(?)       [IN]        For interpretation
  803.  * RETURNS
  804.  *  pBOOL
  805.  *****************************************************************************/
  806. pBOOL IsStandardGsmSS(PU8 dtmfBuf)
  807. {
  808.     /*----------------------------------------------------------------*/
  809.     /* Local Variables                                                */
  810.     /*----------------------------------------------------------------*/
  811.     PU8 tmpBuf = dtmfBuf;
  812.     CM_CALL_HANDLE callVal;
  813.     S32 bufLen;
  814.     pBOOL valid = FALSE;
  816.     /*----------------------------------------------------------------*/
  817.     /* Code Body                                                      */
  818.     /*----------------------------------------------------------------*/
  819.     if (GetTotalCallCount() == 0)
  820.     {
  821.         return FALSE;
  822.     }
  824.     /* second digit must be NULL, *, or 0~9 */
  825.     if ((*(tmpBuf + 1) == 0) || (*(tmpBuf + 1) == '*') || ((*(tmpBuf + 1) >= '0') && (*(tmpBuf + 1) <= '9')))
  826.     {
  827.         valid = TRUE;
  828.     }
  830.     if (valid == TRUE)
  831.     {
  832.         switch (*tmpBuf)
  833.         {
  834.             case '0':
  835.                 if ('' == *(tmpBuf + 1))
  836.                 {
  837.                     /* 0 send */
  838.                     if (-1 != GetIncomingCallHandle())
  839.                     {
  840.                         /* incoming call present => reject waiting call */
  841.                         if (GetTotalCallCount() > 1)
  842.                         {
  843.                             PRINT_INFORMATION(("n *** Reject Waiting Calln"));
  844.                             KbCBackCallIncomingRejected();
  845.                             return TRUE;
  846.                         }
  847.                         else
  848.                         {
  849.                             valid = TRUE;
  850.                             break;
  851.                         }
  852.                     }
  853.                     else
  854.                     {
  855.                         /* no incoming call, drop held call */
  856.                         if ((GetTotalHoldCallCount() > 0) ||
  857.                             ((GetTotalActiveCallCount() > 0) && (GetCurrentState() == CM_OUTGOING_STATE)))
  858.                         {
  859.                             PRINT_INFORMATION(("n *** Hanging Up All Holdn"));
  860.                             HangupallHeld();
  861.                             return TRUE;
  862.                         }
  863.                         else
  864.                         {
  865.                             valid = TRUE;
  866.                             break;
  867.                         }
  868.                     }
  869.                 }
  870.                 valid = FALSE;
  871.                 break;
  873.             case '1':
  874.                 if ('' == *(tmpBuf + 1))
  875.                 {
  876.                     /* 1 send */
  877.                     if (GetCurrentState() == CM_INCOMING_STATE)
  878.                     {
  879.                         if (GetTotalCallCount() == 1)
  880.                         {
  881.                             valid = TRUE;
  882.                             break;
  883.                         }
  884.                         else
  885.                         {
  886.                             KbCBackEndActiveAcceptIncomingCall();
  887.                             return TRUE;
  888.                         }
  889.                     }
  890.                     else if (GetCurrentState() == CM_OUTGOING_STATE)
  891.                     {
  892.                         valid = TRUE;
  893.                         break;
  894.                     }
  895.                     else
  896.                     {
  897.                         if (GetTotalCallCount() > 0)
  898.                         {
  899.                             ProcessIncomingEvents(CM_KB_END_ALL_ACTIVE_RETRIEVE_HELD, NULL);
  900.                             return TRUE;
  901.                         }
  902.                         else
  903.                         {
  904.                             valid = TRUE;
  905.                             break;
  906.                         }
  907.                     }
  908.                 }
  909.                 else if ('' == *(tmpBuf + 2))
  910.                 {
  911.                     /* 1X send */
  912.                     PRINT_INFORMATION(("n *** Hanging Up Active call n"));
  914.                     callVal = (CM_CALL_HANDLE) atoi((void*)(tmpBuf + 1));
  916.                     if (callVal != 0 && GetCallState(callVal) == CM_ACTIVE_STATE &&
  917.                         GetCurrentState() != CM_OUTGOING_STATE)
  918.                     {
  919.                         HangupCall(callVal);
  920.                         return TRUE;
  921.                     }
  922.                     else
  923.                     {
  924.                         valid = TRUE;
  925.                         break;
  926.                     }
  927.                 }
  928.                 valid = FALSE;
  929.                 break;
  931.             case '2':
  932.                 if ('' == *(tmpBuf + 1))
  933.                 {
  934.                     /* 2 send */
  935.                     if (GetWapCallPresent())
  936.                     {
  937.                         valid = TRUE;
  938.                         break;
  939.                     }
  940.                     if (CM_INCOMING_STATE == GetCurrentState())
  941.                     {
  942.                         KbCBackCallIncomingAccepted();
  943.                         return TRUE;
  944.                     }
  945.                     else if (GetCurrentState() == CM_OUTGOING_STATE)
  946.                     {
  947.                         valid = TRUE;
  948.                         break;
  949.                     }
  951.                     OutgoingProcessCMEvent(CM_KB_SWAPREQ, NULL);
  952.                     return TRUE;
  953.                 }
  954.                 else if ('' == *(tmpBuf + 2))
  955.                 {
  956.                     /* 2X send */
  957.                     callVal = (CM_CALL_HANDLE) atoi((void*)(tmpBuf + 1));
  959.                     if (callVal == 0 || (GetCallState(callVal) != CM_ACTIVE_STATE))
  960.                     {
  961.                         valid = TRUE;
  962.                         break;
  963.                     }
  964.                     if ((GetTotalActiveCallCount() > 1) &&
  965.                         (GetTotalHoldCallCount() == 0) && (GetCurrentState() != CM_OUTGOING_STATE))
  966.                     {
  967.                         PRINT_INFORMATION(("n *** Splitting Call n"));
  968.                         SplitCall(callVal);
  969.                         return TRUE;
  970.                     }
  971.                     else
  972.                     {
  973.                         valid = TRUE;
  974.                         break;
  975.                     }
  976.                 }
  977.                 valid = FALSE;
  978.                 break;
  980.             case '3':
  981.                 if ('' == *(tmpBuf + 1))
  982.                 {
  983.                     /* 3 send */
  984.                     if ((GetTotalActiveCallCount() < MAX_HOLD) &&
  985.                         (GetTotalHoldCallCount() < MAX_HOLD) &&
  986.                         ((GetTotalActiveCallCount() > 0 && GetTotalHoldCallCount() > 0)))
  987.                     {
  988.                         PRINT_INFORMATION(("n *** Conferencing Call n"));
  989.                         ConferenceCall();
  990.                         return TRUE;
  991.                     }
  992.                     else
  993.                     {
  994.                         valid = TRUE;
  995.                         break;
  996.                     }
  997.                 }
  998.                 valid = FALSE;
  999.                 break;
  1001.             case '4':
  1002.                 if ('*' == *(tmpBuf + 1))
  1003.                 {
  1004.                     /* 4* send */
  1005.                     if ((-1 != GetIncomingCallHandle()))
  1006.                     {
  1007.                         bufLen = strlen((PS8) tmpBuf);
  1008.                         if (tmpBuf[bufLen - 1] >= '0' && tmpBuf[bufLen - 1] <= '9')
  1009.                         {
  1010.                             PRINT_INFORMATION(("n *** Call Deflectionn"));
  1011.                             gCallDeflectNumber = tmpBuf + 2;
  1012.                             OutgoingProcessCMEvent(CM_KB_CALL_DEFLECT_REQ, gCallDeflectNumber);
  1013.                             return TRUE;
  1014.                         }
  1015.                     }
  1016.                     else
  1017.                     {
  1018.                         //PRINT_INFORMATION (("n *** Not a valid action n"));
  1019.                         //ShowCallManagementErrorMessage(NO_ACTIVE_CALL);
  1020.                         //return TRUE;
  1021.                         valid = FALSE;
  1022.                         break;
  1023.                     }
  1024.                 }
  1025.                 else if ('' == *(tmpBuf + 1))
  1026.                 {
  1027.                     /* 4 send */
  1028.                     if ((GetTotalActiveCallCount() == 1 && (-1 != GetOutgoingCallHandle())) ||
  1029.                         (GetTotalHoldCallCount() == 1 && (-1 != GetOutgoingCallHandle())) ||
  1030.                         (GetTotalActiveCallCount() == 1 && GetTotalHoldCallCount() == 1))
  1031.                     {
  1032.                         PRINT_INFORMATION(("n *** Explicit Call Transfern"));
  1033.                         TransferCall();
  1034.                         return TRUE;
  1035.                     }
  1036.                     else
  1037.                     {
  1038.                         valid = TRUE;
  1039.                         break;
  1040.                     }
  1041.                 }
  1042.                 valid = FALSE;
  1043.                 break;
  1045.             case '5':
  1046.                 if ('' == *(tmpBuf + 1))
  1047.                 {
  1048.                     /* 5 send */
  1049.                     if (GetCCBSFlag() == TRUE)
  1050.                     {
  1051.                         PRINT_INFORMATION(("n *** CCBS Activationn"));
  1052.                         ActivateCCBS();
  1053.                         return TRUE;
  1054.                     }
  1055.                     else
  1056.                     {
  1057.                         valid = TRUE;
  1058.                         break;
  1059.                     }
  1060.                 }
  1061.                 valid = FALSE;
  1062.                 break;
  1064.             default:
  1065.                 valid = FALSE;
  1066.                 break;
  1068.         }
  1069.     }
  1071.     if (GetTotalCallCount() == 1 && GetCurrentState() == CM_INCOMING_STATE)
  1072.     {
  1073.         /* answer */
  1074.         KbCBackCallIncomingAccepted();
  1075.         /* ProcessIncomingEvents (CM_KB_INCOMING_CALL_ACCEPT,NULL); */
  1076.         return TRUE;
  1077.     }
  1078.     else if (valid == TRUE)
  1079.     {
  1080.         PRINT_INFORMATION(("n Not a valid actionn"));
  1081.         ShowCallManagementErrorMessage(NO_ACTIVE_CALL);
  1082.         return TRUE;
  1083.     }
  1084.     return FALSE;
  1085. }
  1088. /*****************************************************************************
  1089.  * FUNCTION
  1090.  *  isHashString
  1091.  * DESCRIPTION
  1092.  *  Helper function to check is this is a # string
  1093.  * PARAMETERS
  1094.  *  buf             [IN]        
  1095.  *  Buffer(?)       [IN]        Containing USSD string
  1096.  * RETURNS
  1097.  *  void
  1098.  *****************************************************************************/
  1099. pBOOL isHashString(PU8 buf)
  1100. {
  1101.     /*----------------------------------------------------------------*/
  1102.     /* Local Variables                                                */
  1103.     /*----------------------------------------------------------------*/
  1104.     U16 count = 0;
  1106.     /*----------------------------------------------------------------*/
  1107.     /* Code Body                                                      */
  1108.     /*----------------------------------------------------------------*/
  1109.     while ('' != buf[count])
  1110.     {
  1111.         if ('#' == buf[count])
  1112.         {
  1113.             return TRUE;
  1114.         }
  1115.         if (count >= MAX_DIGIT)
  1116.         {
  1117.             return FALSE;
  1118.         }
  1119.         count++;
  1121.     }
  1122.     return FALSE;
  1123. }
  1126. /*****************************************************************************
  1127.  * FUNCTION
  1128.  *  isShortString
  1129.  * DESCRIPTION
  1130.  *  Helper function to check is this is a short string
  1131.  * PARAMETERS
  1132.  *  buf             [IN]        
  1133.  *  Buffer(?)       [IN]        Containing USSD string
  1134.  * RETURNS
  1135.  *  void
  1136.  *****************************************************************************/
  1137. pBOOL isShortString(PU8 buf)
  1138. {
  1139.     /*----------------------------------------------------------------*/
  1140.     /* Local Variables                                                */
  1141.     /*----------------------------------------------------------------*/
  1142.     U16 count = 0;
  1144.     /*----------------------------------------------------------------*/
  1145.     /* Code Body                                                      */
  1146.     /*----------------------------------------------------------------*/
  1147.     while ('' != buf[count++])
  1148.         if (count > 2)
  1149.         {
  1150.             return FALSE;
  1151.         }
  1153.     return TRUE;
  1154. }
  1157. /*****************************************************************************
  1158.  * FUNCTION
  1159.  *  UCS2StrNoFirstPositionSearch
  1160.  * DESCRIPTION
  1161.  *  Search for a character in string for only first position
  1162.  * PARAMETERS
  1163.  *  strNumber           [IN]        
  1164.  *  charToSearch        [IN]        
  1165.  * RETURNS
  1166.  *  pBOOL
  1167.  *****************************************************************************/
  1168. pBOOL UCS2StrNoFirstPositionSearch(PS8 strNumber, S8 charToSearch)
  1169. {
  1170.     /*----------------------------------------------------------------*/
  1171.     /* Local Variables                                                */
  1172.     /*----------------------------------------------------------------*/
  1173.     U16 pos;
  1175.     /*----------------------------------------------------------------*/
  1176.     /* Code Body                                                      */
  1177.     /*----------------------------------------------------------------*/
  1178.     PRINT_INFORMATION(("nIn UCS2StrNoFirstPositionSearchn"));
  1180.     if (strNumber[0] == charToSearch)
  1181.     {
  1182.         return FALSE;
  1183.     }
  1184.     else
  1185.     {
  1186.         pos = 2;
  1187.         while (strNumber[pos] != '')
  1188.         {
  1189.             if (strNumber[pos] == charToSearch)
  1190.             {
  1191. if (strNumber[pos+2] != '*' && strNumber[pos+2] != '#')
  1192.                     return TRUE;
  1193. else
  1194.     return FALSE;
  1195.             }
  1196.             pos = pos + 2;
  1197.         }
  1198.         return TRUE;
  1199.     }
  1200. }
  1203. /*****************************************************************************
  1204.  * FUNCTION
  1205.  *  UCS2StrFirstPositionSearch
  1206.  * DESCRIPTION
  1207.  *  Search for a '+' character in string for only first position
  1208.  * PARAMETERS
  1209.  *  strNumber       [IN]        
  1210.  * RETURNS
  1211.  *  pBOOL
  1212.  *****************************************************************************/
  1213. pBOOL UCS2StrFirstPositionSearch(PS8 strNumber)
  1214. {
  1215.     /*----------------------------------------------------------------*/
  1216.     /* Local Variables                                                */
  1217.     /*----------------------------------------------------------------*/
  1218.     U16 pos;
  1220.     /* pBOOL firstFlag=FALSE; */
  1221.     pBOOL secondFlag = FALSE;
  1222.     S8 charToSearch = '+';
  1223.     U8 length;
  1225.     /*----------------------------------------------------------------*/
  1226.     /* Code Body                                                      */
  1227.     /*----------------------------------------------------------------*/
  1228.     PRINT_INFORMATION(("nIn UCS2StrFirstPositionSearchn"));
  1230.     //if(strNumber[0]==charToSearch)
  1231.     //   firstFlag=TRUE;
  1232. length = pfnUnicodeStrlen(strNumber);
  1234.     pos = 2;
  1235.     while (strNumber[pos] != '')
  1236.     {
  1237.         if ((strNumber[pos] == charToSearch) && 
  1238.             ((strNumber[pos - 2] != '#' && strNumber[pos - 2] != '*' &&
  1239.              strNumber[(length-1)<<1] != '#') ||
  1240.              (strNumber[0] == charToSearch)))
  1241.         {
  1242.             secondFlag = TRUE;
  1243.             break;
  1244.         }
  1245.         pos = pos + 2;
  1246.     }
  1248.     if (secondFlag == FALSE)
  1249.     {
  1250.         return TRUE;
  1251.     }
  1252.     else
  1253.     {
  1254.         return FALSE;
  1255.     }
  1256. }
  1259. /*****************************************************************************
  1260.  * FUNCTION
  1261.  *  ShowOutgoingIndicationScreen
  1262.  * DESCRIPTION
  1263.  *  Shows only outgoing call screen and takes control
  1264.  * PARAMETERS
  1265.  *  number          [IN]        
  1266.  *  Number(?)       [IN]        To show on screen
  1267.  * RETURNS
  1268.  *  void
  1269.  *****************************************************************************/
  1270. void ShowOutgoingIndicationScreen(PU8 number)
  1271. {
  1272.     /*----------------------------------------------------------------*/
  1273.     /* Local Variables                                                */
  1274.     /*----------------------------------------------------------------*/
  1276.     /*----------------------------------------------------------------*/
  1277.     /* Code Body                                                      */
  1278.     /*----------------------------------------------------------------*/
  1279.     /* for SAT MO only  */
  1281.     SetSATScrnSavedFlag(FALSE);
  1283.     SetPreviousState((CALL_STATE) GetCurrentState());
  1284.     SetCurrentState(CM_OUTGOING_STATE);
  1286.     gtmpOutgoingIndex = GetFirstFreeIndex();
  1287.     AddNewCallInfo(
  1288.         number,
  1289.         (CALL_STATE) GetCurrentState(),
  1290.         CM_IDLE_STATE,
  1291.         CM_CALL_MO_STK,
  1292.         (CM_CALL_HANDLE) (gtmpOutgoingIndex + 1),
  1293.         CSMCC_VOICE_CALL);
  1295.     OutgoingProcessCMEvent(CM_PS_SHOW_OUTGOING_CALL_SCREEN, NULL);
  1296.     SetSATScrnSavedFlag(TRUE);
  1297. }
  1300. /*****************************************************************************
  1301.  * FUNCTION
  1302.  *  RemoveOutgoingIndicationScreen
  1303.  * DESCRIPTION
  1304.  *  Removes outgoing call screen
  1305.  * PARAMETERS
  1306.  *  void
  1307.  *  Number(?)       [IN]        To show on screen
  1308.  * RETURNS
  1309.  *  void
  1310.  *****************************************************************************/
  1311. void RemoveOutgoingIndicationScreen(void)
  1312. {
  1313.     /*----------------------------------------------------------------*/
  1314.     /* Local Variables                                                */
  1315.     /*----------------------------------------------------------------*/
  1316.     CM_CALL_HANDLE handle;
  1318.     /*----------------------------------------------------------------*/
  1319.     /* Code Body                                                      */
  1320.     /*----------------------------------------------------------------*/
  1321.     /* SAT MO fail case */
  1322.     handle = GetOutgoingCallHandle();
  1323.     if (handle == -1)
  1324.     {
  1325.         return;
  1326.     }
  1328.     SetCallState(handle, CM_IDLE_STATE, TRUE);
  1329.     SetCurrentState(GetPreviousState());
  1330.     SetPreviousState(CM_OUTGOING_STATE);
  1332.     if (FALSE == GetSATScrnSavedFlag())
  1333.     {
  1334.         EntryNewScreen(GLOBAL_SCR_DUMMY, NULL, NULL, NULL);
  1335.         SetSATScrnSavedFlag(TRUE);
  1336.     }
  1337.     SetCallEndedBeforeConnFlag(FALSE);
  1338.     /* GoBackfromNotifyScr(); */
  1339.     ShowCallManagementErrorMessage(ERR_L4C_GEN_CAUSE);
  1340. }
  1343. /*****************************************************************************
  1344.  * FUNCTION
  1345.  *  PsCBackSetCallFeatures
  1346.  * DESCRIPTION
  1347.  *  This Sets the features of the call as per
  1348.  * PARSING STR RSP
  1349.  *  
  1350.  *  
  1351.  *  PARSING_STRING_RSP from PS
  1352.  * PARAMETERS
  1353.  *  info        [?]     
  1354.  * RETURNS
  1355.  *  void
  1356.  *****************************************************************************/
  1357. void PsCBackSetCallFeatures(void *info)
  1358. {
  1359.     /*----------------------------------------------------------------*/
  1360.     /* Local Variables                                                */
  1361.     /*----------------------------------------------------------------*/
  1362.     MMI_PARSE_STR_RSP *rsp;
  1363.     CM_CALL_HANDLE handle = -1;
  1365.     /*----------------------------------------------------------------*/
  1366.     /* Code Body                                                      */
  1367.     /*----------------------------------------------------------------*/
  1368.     PRINT_INFORMATION(("XXX In PsCBackSetCallFeatures n"));
  1370.     rsp = (MMI_PARSE_STR_RSP*) info;
  1372.     if (TRUE == DeriveAndSetCallFeatures(info))
  1373.     {
  1374.         if (GetCCFlag() == TRUE)
  1375.         {
  1376.             PHB_CM_INTERFACE PhoneNumberStruct;
  1378.             /* MO call */
  1379.         #ifdef __MMI_BT_PROFILE__
  1380.             /* stop audio background play before sco link */
  1381.             mdi_audio_suspend_background_play();
  1382.             /* establish sco link here */
  1383.             mmi_profiles_bt_call_start_callback();
  1384.         #endif /* __MMI_BT_PROFILE__ */ 
  1385.             /* look up dialed number from phonebook first anyway */
  1387.             /* auto redial and dial from list */
  1388.             if (cm_p->redial_info.DialFromPhb != MMI_PHB_NONE)
  1389.             {
  1390.                 mmi_phb_call_set_dial_from_list(cm_p->redial_info.DialFromPhb);
  1391.             }
  1393.             PhoneNumberStruct = mmi_phb_call_get_data_for_call_mgnt(GetOutgoingNumber(), TRUE);
  1394.             SetCMPhoneBookStruct(&PhoneNumberStruct);
  1395.             /* PhoneNumberStruct = GetCMPhoneBookStruct(); */
  1397.             if (CHISTGetDialFromCallLogFlag() == 0)
  1398.             {
  1399.                 /* not dial from call log => use phonebook data and name */
  1400.                 PRINT_INFORMATION(("*** In PsCBackSetCallFeatures, set MO name from PHB1 ***n"));
  1401.                 SetOutgoingNamefromPhonebook();
  1402.             }
  1403.             else if (pfnUnicodeStrcmp((PS8) PhoneNumberStruct.name, (PS8) GetOutgoingName()) != 0)
  1404.             {
  1405.                 /* dial from call log but phonebook name not match => don't use phonebook data */
  1406.                 PRINT_INFORMATION(("*** In PsCBackSetCallFeatures, set MO name from Call Log ***n"));
  1407.                 memset(&PhoneNumberStruct, 0, sizeof(PHB_CM_INTERFACE));
  1408.                 PhoneNumberStruct.pictureId = IMG_PHB_DEFAULT;
  1409.                 SetCMPhoneBookStruct(&PhoneNumberStruct);
  1410.             }
  1411.             else
  1412.             {
  1413.                 /* dial from call log but still use phonebook data */
  1414.                 PRINT_INFORMATION(("*** In PsCBackSetCallFeatures, set MO name from PHB2 ***n"));
  1415.             }
  1417.             AlmDisableExpiryHandler();
  1418.             OutgoingProcessCMEvent(CM_PS_SHOW_OUTGOING_CALL_SCREEN, NULL);
  1419.             CHISTSetDialFromCallLogFlag(0);
  1420.             return;
  1421.         }
  1422.         else if (rsp->info.opcode == SS_OPERATION)
  1423.         {
  1424.             /* SS string */
  1425.             if (GetCurrentState() == CM_INCOMING_STATE)
  1426.             {
  1427.                 history ss_scr;
  1428.                 S16 nHistory = 0;
  1429. //micha1106
  1430.                 if (!IsScreenPresent(SCR_CM_REQUESTINGUSSD))
  1431.                 {
  1432.                     ss_scr.scrnID = SCR_CM_REQUESTINGUSSD;
  1433.                     ss_scr.entryFuncPtr = EntryScrUSSDReq;
  1434.                     pfnUnicodeStrcpy((S8*) ss_scr.inputBuffer, (S8*) & nHistory);
  1435.                     InsertHistoryBeforeThisScrnReference(CM_SCR_MARKER, &ss_scr);
  1436.                 }
  1437.             }
  1438.             else
  1439.             {
  1440.                 OutgoingProcessCMEvent(CM_PS_SHOW_REQUESTING_CALL_SCREEN, NULL);
  1441.             }
  1442.         }
  1443.         else
  1444.         {
  1445.             /* must be SIM operation */
  1446.             /* OutgoingProcessCMFailureEvent(CM_PS_CALLCONNECTED, ERR_INVALID_NUMBER_FORMAT); */
  1447.         }
  1448.     }
  1449.     else if ((rsp->result.flag == 0) && (rsp->info.opcode == SIM_OPERATION))
  1450.     {
  1451.         DisplayPopup((PU8) GetString(STR_GLOBAL_NOT_DONE), IMG_GLOBAL_UNFINISHED, 0, CS_NOTIFYDURATION, ERROR_TONE);
  1452.     }
  1453.     else if ((rsp->result.flag == 0) && (rsp->info.opcode == INVALID_OPERATION))
  1454.     {
  1455.         if (rsp->result.cause == PHB_L4C_ERROR)
  1456.         {
  1457.             OutgoingProcessCMFailureEvent(CM_PS_CALLCONNECTED, ERR_L4C_FDN_FAIL);
  1458.         }
  1459.         else if (rsp->result.cause == L4C_CMD_CONFLICT)
  1460.         {
  1461.             OutgoingProcessCMFailureEvent(CM_PS_CALLCONNECTED, ERR_L4C_GEN_CAUSE);
  1462.         }
  1463.         else
  1464.         {
  1465.             OutgoingProcessCMFailureEvent(CM_PS_CALLCONNECTED, ERR_INVALID_NUMBER_FORMAT);
  1466.         }
  1467.     }
  1468.     else
  1469.     {
  1470.         OutgoingProcessCMFailureEvent(CM_PS_CALLCONNECTED, ERROR_FAIL);
  1471.         RemoveSSReqScr();
  1472.     }
  1474.     g_phb_cntx.dial_from_list = MMI_PHB_NONE;
  1475.     PurgeOutgoingCallsStructure();
  1476.     SetCallEndedBeforeConnFlag(FALSE);
  1477.     CHISTSetDialFromCallLogFlag(0);
  1479.     SetCurrentState(GetPreviousState());
  1480.     if (GetPreviousState() == CM_INCOMING_STATE)
  1481.     {
  1482.         if (GetTotalCallCount() == 1)
  1483.         {
  1484.             SetPreviousState(CM_IDLE_STATE);
  1485.         }
  1486.         else if (GetTotalActiveCallCount() == GetTotalCallCount() - 1)
  1487.         {
  1488.             SetPreviousState(CM_ACTIVE_STATE);
  1489.         }
  1490.         else if (GetTotalHoldCallCount() == GetTotalCallCount() - 1)
  1491.         {
  1492.             SetPreviousState(CM_HOLD_STATE);
  1493.         }
  1494.     }
  1496.     /* reset phb data */
  1497.     if (GetCurrentState() == CM_INCOMING_STATE)
  1498.     {
  1499.         handle = GetIncomingCallHandle();
  1500.     }
  1501.     else if (GetCurrentState() == CM_OUTGOING_STATE)
  1502.     {
  1503.         handle = GetOutgoingCallHandle();
  1504.     }
  1505.     if (handle != -1)
  1506.     {
  1507.         PHB_CM_INTERFACE phb_data;
  1509.         phb_data = mmi_phb_call_get_data_for_call_mgnt(GetCallNumber(handle), FALSE);
  1510.     #ifdef __MMI_INCOMING_CALL_VIDEO__
  1511.         /* waiting call and ccbs invoke can't use video for display */
  1512.         if (GetTotalCallCount() > 0 || GetCCBSFlag() == TRUE)
  1513.         {
  1514.             phb_data.videoId = 0;
  1515.         }
  1516.     #endif /* __MMI_INCOMING_CALL_VIDEO__ */ 
  1517.         SetCMPhoneBookStruct(&phb_data);
  1518.     }
  1519.     SetDefaultVolumeKeyHandlers();
  1520.     return;
  1521. }
  1524. /*****************************************************************************
  1525.  * FUNCTION
  1526.  *  PsCbackOutgoingCallIdSync
  1527.  * DESCRIPTION
  1528.  *  Helper function to get call list from PS to sync with MMI
  1529.  *  
  1530.  *  DIAL_IND from PS.
  1531.  * PARAMETERS
  1532.  *  MsgStruct       [?]     
  1533.  * RETURNS
  1534.  *  void
  1535.  *****************************************************************************/
  1536. void PsCbackOutgoingCallIdSync(void *MsgStruct)
  1537. {
  1538.     /*----------------------------------------------------------------*/
  1539.     /* Local Variables                                                */
  1540.     /*----------------------------------------------------------------*/
  1541.     CM_CALL_HANDLE handle;
  1542.     U16 response;
  1544.     /*----------------------------------------------------------------*/
  1545.     /* Code Body                                                      */
  1546.     /*----------------------------------------------------------------*/
  1547.     PRINT_INFORMATION(("XXX - In PsCbackOutgoingCallIdSync XXXn"));
  1549.     handle = DeriveOutgoingCallIdRsp(MsgStruct, &response);
  1550.     if (handle == -1 || handle > MAX_CALLS)
  1551.     {
  1552.         if (GetDialIndication() == TRUE)
  1553.         {
  1554.             ShowCallManagementErrorMessage(NO_ACTIVE_CALL);
  1555.             return;
  1556.         }
  1558.         PRINT_INFORMATION(("Error in making outgoing call %d", response));
  1559.         /* keep MO fail cause for later display if notify ss is ongoing */
  1560.         SetCallEndCause(response);
  1562.         /* MO fail */
  1563.         /* SyncCallList(); */
  1564.         SetDialIndication(FALSE);
  1566.         LogCallInfoForCallHistory(GetOutgoingCallHandle());
  1567.         GetEndTimeAndLogUnconnectedMOCall();
  1569.         if (IsRedialSet())
  1570.         {
  1571.             SetRedialNumber();
  1572.         }
  1574.         OutgoingProcessCMFailureEvent(CM_PS_CALLCONNECTED, response);
  1575.         /* reset call end before conn flag for next call */
  1576.         SetCallEndedBeforeConnFlag(FALSE);
  1577.     }
  1578.     else
  1579.     {
  1580.         SetOutgoingCallHandle(handle);
  1581.         SetDialIndication(TRUE);
  1582.         if (GetTotalCallCount() > 1)
  1583.         {
  1584.             SyncCallList();
  1585.         }
  1586.     }
  1587. }
  1590. /*****************************************************************************
  1591.  * FUNCTION
  1592.  *  OutgoingCallConnected
  1593.  * DESCRIPTION
  1594.  *  Helper function to Generate CM known Stack Event CM_PS_CALLCONNECTED
  1595.  *  with the Structure containing CM_CALL_HANDLE.
  1596.  *  
  1597.  *  We could have mapped void* to CM_CALL_HANDLE and passed it to the
  1598.  *  state m/c. CONNECT_IND from PS
  1599.  * PARAMETERS
  1600.  *  MsgStruct       [?]         
  1601.  *  This(?)         [IN]        Contains CM_CALL_HANDLE passed by the stack when call is connected)
  1602.  * RETURNS
  1603.  *  void
  1604.  *****************************************************************************/
  1605. void OutgoingCallConnected(void *MsgStruct)
  1606. {
  1607.     /*----------------------------------------------------------------*/
  1608.     /* Local Variables                                                */
  1609.     /*----------------------------------------------------------------*/
  1610.     MMI_CONNECT_IND *msg;
  1611.     CM_CALL_HANDLE handle;
  1612.     MYTIME t;
  1614.     /*----------------------------------------------------------------*/
  1615.     /* Code Body                                                      */
  1616.     /*----------------------------------------------------------------*/
  1617. #if defined (JATAAYU_SUPPORT) && defined (WAP_SUPPORT)
  1618. mmi_jdd_tapi_make_call_result(JC_OK);
  1619. #endif
  1621.     msg = (MMI_CONNECT_IND*) MsgStruct;
  1623.     PRINT_INFORMATION(("XXX - In OutgoingCallConnected XXXn"));
  1625.     if (GetInternalAlert() == TRUE)
  1626.     {
  1627.         StopInternalOutgoingTone();
  1628.     }
  1630.     SetSpeechFlag(FALSE);
  1632.     if (CM_CSD_CALL == (msg->call_type))
  1633.     {
  1634.         SetWapCallPresent(TRUE);
  1635.     }
  1637.     if (GetTotalCallCount() <= 1)
  1638.     {
  1639.     #ifdef __MMI_CONNECT_NOTICE__
  1640.         /* play connect notice according to user defined style */
  1641.         PlayConnectNotice();
  1642.     #else /* __MMI_CONNECT_NOTICE__ */ 
  1643.         playRequestedTone(CONNECT_TONE);
  1644.     #endif /* __MMI_CONNECT_NOTICE__ */ 
  1645.     }
  1647.     if (GetOutgoingCallOrigin() == CM_CALL_MO_STK)
  1648.     {
  1649.         /* STK call doesn't have DIAL_IND, so need to set call id in CONNECT_IND */
  1650.         SetOutgoingCallHandle(msg->call_id);
  1651.     }
  1653.     handle = GetOutgoingCallHandle();
  1655.     /* log MO call with original number and name */
  1656.     SetCalledNumWithTypeAux(GetMMIStructIndexof(handle), MsgStruct);
  1657.     DTGetRTCTime(&t);
  1658.     UpdateCallStartTimeAndLogCall(handle, &t);
  1659.     
  1660.     /* set MO name for display in case number is changed by PS */
  1661.     SetCalledNumWithType(GetMMIStructIndexof(handle), MsgStruct);
  1663. #ifdef __IP_NUMBER__
  1664.     SetTempUseIPNumber(FALSE);
  1665. #endif 
  1667.     OutgoingProcessCMEvent(CM_PS_CALLCONNECTED, &handle);
  1668. }
  1671. /*****************************************************************************
  1672.  * FUNCTION
  1673.  *  PsCBackOutgoingCallEnded
  1674.  * DESCRIPTION
  1675.  *  Call Back function for ATH_SUCCESS to hangup outgoing call
  1676.  *  
  1677.  *  ATH_RSP from PS
  1678.  * PARAMETERS
  1679.  *  MsgStruct       [?]         
  1680.  *  expected(?)     [IN]        NULL
  1681.  * RETURNS
  1682.  *  void
  1683.  *****************************************************************************/
  1684. void PsCBackOutgoingCallEnded(void *MsgStruct)
  1685. {
  1686.     /*----------------------------------------------------------------*/
  1687.     /* Local Variables                                                */
  1688.     /*----------------------------------------------------------------*/
  1689.     CM_CALL_HANDLE handle;
  1691.     /*----------------------------------------------------------------*/
  1692.     /* Code Body                                                      */
  1693.     /*----------------------------------------------------------------*/
  1694. #if defined (JATAAYU_SUPPORT) && defined (WAP_SUPPORT)
  1695. mmi_jdd_tapi_make_call_result(JC_ERR_UNKNOWN);
  1696. #endif
  1698.     SetCallAbortReqSentFlag(FALSE);
  1700.     if (GetCurrentState() == CM_IDLE_STATE)
  1701.     {
  1702.         PRINT_INFORMATION(("XXX - In PsCBackOutgoingCallEnded no call to drop XXXn"));
  1703.         /* SetDropRequestFlag(FALSE); */
  1704.         return;
  1705.     }
  1707.     if ((handle = GetOutgoingCallHandle()) == -1)
  1708.     {
  1709.         /* MO call already got connected before it's aborted */
  1710.         handle = GetHungUpHandle();
  1711.         if (handle == -1)
  1712.         {
  1713.             PRINT_INFORMATION(("XXX - In PsCBackOutgoingCallEnded call already dropped XXXn"));
  1714.             return;
  1715.         }
  1716.     }
  1718.     OutgoingProcessCMEvent(CM_PS_HANGUPSUC, (void*)&handle);
  1719.     SetProtocolEventHandler(PsCBackNetworkCallDropped, PRT_NWRK_CALL_RELEASE);
  1720. }
  1723. /*****************************************************************************
  1724.  * FUNCTION
  1725.  *  PsCBackUSSDResponse
  1726.  * DESCRIPTION
  1727.  *  This function is called back by the protocol stack when USSD data is recieved by n/w
  1728.  *  
  1729.  *  info is
  1730.  * PARAMETERS
  1731.  *  info        [?]     
  1732.  * RETURNS
  1733.  *  void
  1734.  *****************************************************************************/
  1735. void PsCBackUSSDResponse(void *info)
  1736. {
  1737.     /*----------------------------------------------------------------*/
  1738.     /* Local Variables                                                */
  1739.     /*----------------------------------------------------------------*/
  1741.     /*----------------------------------------------------------------*/
  1742.     /* Code Body                                                      */
  1743.     /*----------------------------------------------------------------*/
  1744.     PRINT_INFORMATION(("XXX - In PsCBackUSSDResponse XXXn"));
  1745.     OutgoingProcessCMEvent(CM_PS_USSD_RECVD, info);
  1746.     /* ProcessIncomingEvents (CM_PS_USSD_RECVD, info); */
  1747. }
  1749. /* Start by Julia: Drop call refinement */
  1752. /*****************************************************************************
  1753.  * FUNCTION
  1754.  *  ReleaseCall
  1755.  * DESCRIPTION
  1756.  *  Invokes the helper function to make the disconnecting call released complete
  1757.  *  
  1758.  *  This is invoked whenever the user press END key in the disconnecting call screen
  1759.  * PARAMETERS
  1760.  *  void
  1761.  * RETURNS
  1762.  *  void
  1763.  *****************************************************************************/
  1764. void ReleaseCall(void)
  1765. {
  1766.     /*----------------------------------------------------------------*/
  1767.     /* Local Variables                                                */
  1768.     /*----------------------------------------------------------------*/
  1769.     U8 count;
  1770.     CM_CALL_HANDLE handle;
  1772.     /*----------------------------------------------------------------*/
  1773.     /* Code Body                                                      */
  1774.     /*----------------------------------------------------------------*/
  1775.     for (count = 0; count < MAX_CALLS; count++)
  1776.     {
  1777.         if (cm_p->state_info.AllCalls[count].curr_state == CM_DISCONNECTING_STATE)
  1778.         {
  1779.             handle = cm_p->state_info.AllCalls[count].call_handle;
  1780.             MakePsReleaseCompleteRequest(handle);
  1781.             OutgoingProcessCMEvent(CM_PS_HANGUPSUC, (void*)&handle);
  1782.             if (GetAutoReleaseFlag() == FALSE)
  1783.             {
  1784.                 return;
  1785.             }
  1786.         }
  1787.     }
  1788.     SetAutoReleaseFlag(FALSE);
  1789. }
  1791. /* End by Julia */
  1794. /*****************************************************************************
  1795.  * FUNCTION
  1796.  *  DropRequest
  1797.  * DESCRIPTION
  1798.  *  Invokes the helper function to hangup or disconnect the call
  1799.  *  which is yet to connect.
  1800.  *  
  1801.  *  This is invoked whenever the User press LSK in the outgoingcallscreen.
  1802.  * PARAMETERS
  1803.  *  void
  1804.  * RETURNS
  1805.  *  void
  1806.  *****************************************************************************/
  1807. void DropRequest(void)
  1808. {
  1809.     /*----------------------------------------------------------------*/
  1810.     /* Local Variables                                                */
  1811.     /*----------------------------------------------------------------*/
  1812.     CM_CALL_HANDLE handle;
  1814.     /*----------------------------------------------------------------*/
  1815.     /* Code Body                                                      */
  1816.     /*----------------------------------------------------------------*/
  1817.     PRINT_INFORMATION(("*** In Drop Requestn"));
  1819.     if (GetNotifySSFlag())
  1820.     {
  1821.         StopTimer(CM_NOTIFYDURATION_TIMER);
  1822.     }
  1824.     if (FALSE == GetAbortCallRequestedFlag())
  1825.     {
  1826.         handle = GetOutgoingCallHandle();
  1827.         if ((GetCallflag(handle, TRUE) & CM_HANGUP_REQUESTED) == 0)
  1828.         {
  1829.             SetDropRequestFlag(TRUE);
  1830.             SetAbortCallRequestedFlag(TRUE);
  1831.             HangupCall(handle);
  1832.             if (GetExitScrnID() == SCR1001_CM_OUTGOINGCALLSCREEN)
  1833.             {
  1834.                 MOMTHideAnimation();
  1835.             }
  1836.         }
  1837.     }
  1838.     else
  1839.     {
  1840.         PRINT_INFORMATION(("*** In   DropRequest .. Not calling dropn"));
  1841.     }
  1842. }
  1845. /*****************************************************************************
  1846.  * FUNCTION
  1847.  *  HangupCall
  1848.  * DESCRIPTION
  1849.  *  Helper function to generate Keybrd Event CM_KB_HANGUPREQ with the OUTGOING_CALL structure.
  1850.  *  
  1851.  *  This invokes the function to process the CM_KB_HANGUPREQ event in the state m/c.
  1852.  * PARAMETERS
  1853.  *  CallHandle      [IN]        
  1854.  *  contains(?)     [IN]        The call handle of the call that needs to be dropped.
  1855.  * RETURNS
  1856.  *  void
  1857.  *****************************************************************************/
  1858. void HangupCall(CM_CALL_HANDLE CallHandle)
  1859. {
  1860.     /*----------------------------------------------------------------*/
  1861.     /* Local Variables                                                */
  1862.     /*----------------------------------------------------------------*/
  1864.     /*----------------------------------------------------------------*/
  1865.     /* Code Body                                                      */
  1866.     /*----------------------------------------------------------------*/
  1867.     PRINT_INFORMATION(("*** In HangupCalln"));
  1868.     OutgoingProcessCMEvent(CM_KB_HANGUPREQ, &CallHandle);
  1869. }
  1872. /*****************************************************************************
  1873.  * FUNCTION
  1874.  *  HangupReqSucess
  1875.  * DESCRIPTION
  1876.  *  Helper function to Generate CM known Stack Event CM_PS_HANGUPSUC
  1877.  *  with the Structure containing CM_CALL_HANDLE.
  1878.  *  
  1879.  *  We are assuming that the protocol stack sends the sucess response for the hangup request
  1880.  *  with the CM_CALL_HANDLE. CHLD RELEASE_SPECIFIC => RELEASE_IND from PS
  1881.  * PARAMETERS
  1882.  *  MsgStruct       [?]         
  1883.  *  This(?)         [IN]        Contains CM_CALL_HANDLE passed by the stack when call drop is success)
  1884.  * RETURNS
  1885.  *  void
  1886.  *****************************************************************************/
  1887. void HangupReqSucess(void *MsgStruct)
  1888. {
  1889.     /*----------------------------------------------------------------*/
  1890.     /* Local Variables                                                */
  1891.     /*----------------------------------------------------------------*/
  1892.     CM_CALL_HANDLE handle;
  1894.     /*----------------------------------------------------------------*/
  1895.     /* Code Body                                                      */
  1896.     /*----------------------------------------------------------------*/
  1897.     PRINT_INFORMATION(("XXX - In HangupReqSucess XXXn"));
  1899.     handle = DeriveCallHandle(MsgStruct);
  1901.     OutgoingProcessCMEvent(CM_PS_HANGUPSUC, (void*)&handle);
  1902.     SetProtocolEventHandler(PsCBackNetworkCallDropped, PRT_NWRK_CALL_RELEASE);
  1903. }
  1906. /*****************************************************************************
  1907.  * FUNCTION
  1908.  *  HangupAll
  1909.  * DESCRIPTION
  1910.  *  Helper function to generate Keybrd Event CM_KB_HANGUPALLREQ with the NULL structure.
  1911.  *  
  1912.  *  This invokes the function to process the CM_KB_HANGUPALLREQ event in the state m/c.
  1913.  * PARAMETERS
  1914.  *  void
  1915.  * RETURNS
  1916.  *  void
  1917.  *****************************************************************************/
  1918. void HangupAll(void)
  1919. {
  1920.     /*----------------------------------------------------------------*/
  1921.     /* Local Variables                                                */
  1922.     /*----------------------------------------------------------------*/
  1923.     U16 scrId;
  1924.     U8 flag;
  1926.     /*----------------------------------------------------------------*/
  1927.     /* Code Body                                                      */
  1928.     /*----------------------------------------------------------------*/
  1929.     flag = GetAllCallFlags();
  1931. #ifdef __MMI_CLAMSHELL__
  1932.     if (GetCurrentState() == CM_INCOMING_STATE && GetTotalCallCount() > 1)
  1933.     {
  1934.         KbCBackCallIncomingRejected();
  1935.         return;
  1936.     }
  1937. #endif /* __MMI_CLAMSHELL__ */ 
  1939.     if (GetTotalActiveCallCount() > 0 && GetTotalHoldCallCount() > 0 &&
  1940.         ((flag & CM_SWAP_REQUESTED) == 0) && ((flag & CM_CONF_REQUESTED) == 0) && ((flag & CM_ECT_REQUESTED) == 0))
  1941.     {
  1942.         /* swapping can't decide which call is active and held, 
  1943.            issue rel all req instead */
  1945.         /* rel active and accept */
  1946.         ProcessIncomingEvents(CM_KB_END_ALL_ACTIVE_RETRIEVE_HELD, NULL);
  1947.     }
  1948.     else
  1949.     {
  1950.         OutgoingProcessCMEvent(CM_KB_HANGUPALLREQ, (void*)NULL);
  1951.     }
  1953.     scrId = GetExitScrnID();
  1954.     if (scrId == SCR1001_CM_OUTGOINGCALLSCREEN || (scrId == SCR_CM_ACTIVECALLSCREEN && GetTotalCallCount() == 1))
  1955.     {
  1956.         MOMTHideAnimation();
  1957.     }
  1958.     /* else
  1959.        EntryScr1002ActiveCall(); */
  1961. }
  1964. /*****************************************************************************
  1965.  * FUNCTION
  1966.  *  HangupallReqSucess
  1967.  * DESCRIPTION
  1968.  *  Helper function to Generate CM known Stack Event CM_PS_HANGUPALLSUC
  1969.  *  with the Structure containing NULL.
  1970.  *  
  1971.  *  We are assuming that the protocol stack sends the Sucess response for the Hangup all calls request
  1972.  *  without any structure.
  1973.  * PARAMETERS
  1974.  *  MsgStruct       [?]         
  1975.  *  This(?)         [IN]        Contains Null)
  1976.  * RETURNS
  1977.  *  void
  1978.  *****************************************************************************/
  1979. void HangupallReqSucess(void *MsgStruct)
  1980. {
  1981.     /*----------------------------------------------------------------*/
  1982.     /* Local Variables                                                */
  1983.     /*----------------------------------------------------------------*/
  1985.     /*----------------------------------------------------------------*/
  1986.     /* Code Body                                                      */
  1987.     /*----------------------------------------------------------------*/
  1988.     gMyhandle = DeriveCallHandle(MsgStruct);
  1989.     PRINT_INFORMATION(("XXX - In HangupallReqSucess XXXn"));
  1990.     OutgoingProcessCMEvent(CM_PS_HANGUPALLSUC, (void*)&gMyhandle);
  1991.     SetProtocolEventHandler(PsCBackNetworkCallDropped, PRT_NWRK_CALL_RELEASE);
  1992. }
  1995. /*****************************************************************************
  1996.  * FUNCTION
  1997.  *  HangupallActive
  1998.  * DESCRIPTION
  1999.  *  Helper function to generate Keybrd Event CM_KB_HANGUPALLACTREQ with the NULL structure.
  2000.  *  
  2001.  *  This invokes the function to process the CM_KB_HANGUPALLACTREQ event in the state m/c.
  2002.  * PARAMETERS
  2003.  *  void
  2004.  * RETURNS
  2005.  *  void
  2006.  *****************************************************************************/
  2007. void HangupallActive(void)
  2008. {
  2009.     /*----------------------------------------------------------------*/
  2010.     /* Local Variables                                                */
  2011.     /*----------------------------------------------------------------*/
  2013.     /*----------------------------------------------------------------*/
  2014.     /* Code Body                                                      */
  2015.     /*----------------------------------------------------------------*/
  2016.     OutgoingProcessCMEvent(CM_KB_HANGUPALLACTREQ, (void*)NULL);
  2017. }
  2020. /*****************************************************************************
  2021.  * FUNCTION
  2022.  *  HangupallActReqSucess
  2023.  * DESCRIPTION
  2024.  *  Helper function to Generate CM known Stack Event CM_PS_HANGUPALLACTSUC
  2025.  *  with the Structure containing NULL.
  2026.  *  
  2027.  *  We are assuming that the protocol stack sends the Sucess response for the Hangup all Active calls
  2028.  *  request without any structure.
  2029.  * PARAMETERS
  2030.  *  MsgStruct       [?]         
  2031.  *  This(?)         [IN]        Contains Null)
  2032.  * RETURNS
  2033.  *  void
  2034.  *****************************************************************************/
  2035. void HangupallActReqSucess(void *MsgStruct)
  2036. {
  2037.     /*----------------------------------------------------------------*/
  2038.     /* Local Variables                                                */
  2039.     /*----------------------------------------------------------------*/
  2041.     /*----------------------------------------------------------------*/
  2042.     /* Code Body                                                      */
  2043.     /*----------------------------------------------------------------*/
  2044.     gMyhandle = DeriveCallHandle(MsgStruct);
  2045.     PRINT_INFORMATION(("XXX - In HangupallActReqSucess XXXn"));
  2046.     OutgoingProcessCMEvent(CM_PS_HANGUPALLACTSUC, (void*)&gMyhandle);
  2047.     SetProtocolEventHandler(PsCBackNetworkCallDropped, PRT_NWRK_CALL_RELEASE);
  2048. }
  2051. /*****************************************************************************
  2052.  * FUNCTION
  2053.  *  HangupallHeld
  2054.  * DESCRIPTION
  2055.  *  Helper function to generate Keybrd Event CM_KB_HANGUPALLHLDREQ with the NULL structure.
  2056.  *  
  2057.  *  This invokes the function to process the CM_KB_HANGUPALLHLDREQ event in the state m/c.
  2058.  * PARAMETERS
  2059.  *  void
  2060.  * RETURNS
  2061.  *  void
  2062.  *****************************************************************************/
  2063. void HangupallHeld(void)
  2064. {
  2065.     /*----------------------------------------------------------------*/
  2066.     /* Local Variables                                                */
  2067.     /*----------------------------------------------------------------*/
  2069.     /*----------------------------------------------------------------*/
  2070.     /* Code Body                                                      */
  2071.     /*----------------------------------------------------------------*/
  2072.     OutgoingProcessCMEvent(CM_KB_HANGUPALLHLDREQ, (void*)NULL);
  2073. }
  2076. /*****************************************************************************
  2077.  * FUNCTION
  2078.  *  HangupallHldReqSucess
  2079.  * DESCRIPTION
  2080.  *  Helper function to Generate CM known Stack Event CM_PS_HANGUPALLHLDSUC
  2081.  *  with the Structure containing NULL.
  2082.  *  
  2083.  *  We are assuming that the protocol stack sends the Sucess response for the Hangup all Held calls
  2084.  *  request without any structure.
  2085.  * PARAMETERS
  2086.  *  MsgStruct       [?]         
  2087.  *  This(?)         [IN]        Contains Null)
  2088.  * RETURNS
  2089.  *  void
  2090.  *****************************************************************************/
  2091. void HangupallHldReqSucess(void *MsgStruct)
  2092. {
  2093.     /*----------------------------------------------------------------*/
  2094.     /* Local Variables                                                */
  2095.     /*----------------------------------------------------------------*/
  2097.     /*----------------------------------------------------------------*/
  2098.     /* Code Body                                                      */
  2099.     /*----------------------------------------------------------------*/
  2100.     gMyhandle = DeriveCallHandle(MsgStruct);
  2101.     PRINT_INFORMATION(("XXX - In HangupallHldReqSucess XXXn"));
  2102.     OutgoingProcessCMEvent(CM_PS_HANGUPALLHLDSUC, (void*)&gMyhandle);
  2103.     SetProtocolEventHandler(PsCBackNetworkCallDropped, PRT_NWRK_CALL_RELEASE);
  2104. }
  2107. /*****************************************************************************
  2108.  * FUNCTION
  2109.  *  MakeActiveCallHold
  2110.  * DESCRIPTION
  2111.  *  Helper function to generate Keybrd Event CM_KB_HOLDREQ with the NULL structure.
  2112.  *  
  2113.  *  This invokes the function to process the CM_KB_HOLDREQ event in the state m/c.
  2114.  * PARAMETERS
  2115.  *  void
  2116.  * RETURNS
  2117.  *  void
  2118.  *****************************************************************************/
  2119. void MakeActiveCallHold(void)
  2120. {
  2121.     /*----------------------------------------------------------------*/
  2122.     /* Local Variables                                                */
  2123.     /*----------------------------------------------------------------*/
  2125.     /*----------------------------------------------------------------*/
  2126.     /* Code Body                                                      */
  2127.     /*----------------------------------------------------------------*/
  2128.     OutgoingProcessCMEvent(CM_KB_HOLDREQ, (void*)NULL);
  2129. }
  2132. /*****************************************************************************
  2133.  * FUNCTION
  2134.  *  HoldReqSucess
  2135.  * DESCRIPTION
  2136.  *  Helper function to Generate CM known Stack Event CM_PS_HOLDSUC
  2137.  *  with the Structure containing NULL.
  2138.  *  
  2139.  *  We are assuming that the protocol stack sends the Sucess response for the Hold request
  2140.  *  without any structure.
  2141.  * PARAMETERS
  2142.  *  MsgStruct       [?]         
  2143.  *  This(?)         [IN]        Contains Null)
  2144.  * RETURNS
  2145.  *  void
  2146.  *****************************************************************************/
  2147. void HoldReqSucess(void *MsgStruct)
  2148. {
  2149.     /*----------------------------------------------------------------*/
  2150.     /* Local Variables                                                */
  2151.     /*----------------------------------------------------------------*/
  2152.     U16 result;
  2154.     /*----------------------------------------------------------------*/
  2155.     /* Code Body                                                      */
  2156.     /*----------------------------------------------------------------*/
  2157.     if (CheckChldRequestSuccess(MsgStruct, &result))
  2158.     {
  2159.         PRINT_INFORMATION(("XXX - In HoldReqSucess XXXn"));
  2160.         OutgoingProcessCMEvent(CM_PS_HOLDSUC, (void*)MsgStruct);
  2161.     }
  2162.     else
  2163.     {
  2164.         PRINT_INFORMATION(("Error in Making Hold call in protocol stack cause %d", result));
  2165.         SetProtocolEventHandler(PsCBackNetworkCallDropped, PRT_NWRK_CALL_RELEASE);
  2166.         ResetHoldFlag();
  2167.         OutgoingProcessCMFailureEvent(CM_PS_HOLDSUC, result);
  2168.     }
  2169. }
  2172. /*****************************************************************************
  2173.  * FUNCTION
  2174.  *  RetrieveHeldCall
  2175.  * DESCRIPTION
  2176.  *  Helper function to generate Keybrd Event CM_KB_RETRIEVEREQ with the NULL structure.
  2177.  *  
  2178.  *  This invokes the function to process the CM_KB_RETRIEVEREQ event in the state m/c.
  2179.  * PARAMETERS
  2180.  *  void
  2181.  * RETURNS
  2182.  *  void
  2183.  *****************************************************************************/
  2184. void RetrieveHeldCall(void)
  2185. {
  2186.     /*----------------------------------------------------------------*/
  2187.     /* Local Variables                                                */
  2188.     /*----------------------------------------------------------------*/
  2190.     /*----------------------------------------------------------------*/
  2191.     /* Code Body                                                      */
  2192.     /*----------------------------------------------------------------*/
  2193.     OutgoingProcessCMEvent(CM_KB_RETRIEVEREQ, (void*)NULL);
  2194. }
  2197. /*****************************************************************************
  2198.  * FUNCTION
  2199.  *  RetrieveReqSucess
  2200.  * DESCRIPTION
  2201.  *  Helper function to Generate CM known Stack Event CM_PS_RETRIEVESUC
  2202.  *  with the Structure containing NULL.
  2203.  *  
  2204.  *  We are assuming that the protocol stack sends the Sucess response for the retrieve request
  2205.  *  without any structure.
  2206.  * PARAMETERS
  2207.  *  MsgStruct       [?]         
  2208.  *  This(?)         [IN]        Contains Null)
  2209.  * RETURNS
  2210.  *  void
  2211.  *****************************************************************************/
  2212. void RetrieveReqSucess(void *MsgStruct)
  2213. {
  2214.     /*----------------------------------------------------------------*/
  2215.     /* Local Variables                                                */
  2216.     /*----------------------------------------------------------------*/
  2217.     U16 result;
  2219.     /*----------------------------------------------------------------*/
  2220.     /* Code Body                                                      */
  2221.     /*----------------------------------------------------------------*/
  2222.     if (CheckChldRequestSuccess(MsgStruct, &result))
  2223.     {
  2224.         PRINT_INFORMATION(("XXX - In RetrieveReqSucess XXXn"));
  2225.         OutgoingProcessCMEvent(CM_PS_RETRIEVESUC, (void*)MsgStruct);
  2226.     }
  2227.     else
  2228.     {
  2229.         PRINT_INFORMATION(("Error in Retriving Hold Call in protocol stack cause %d", result));
  2230.         SetProtocolEventHandler(PsCBackNetworkCallDropped, PRT_NWRK_CALL_RELEASE);
  2231.         ResetRetrieveFlag();
  2232.         OutgoingProcessCMFailureEvent(CM_PS_RETRIEVESUC, result);
  2233.     }
  2234. }
  2237. /*****************************************************************************
  2238.  * FUNCTION
  2239.  *  SwapCall
  2240.  * DESCRIPTION
  2241.  *  Helper function to generate Keybrd Event CM_KB_SWAPREQ with the NULL structure.
  2242.  *  
  2243.  *  This invokes the function to process the CM_KB_SWAPREQ event in the state m/c.
  2244.  * PARAMETERS
  2245.  *  void
  2246.  * RETURNS
  2247.  *  void
  2248.  *****************************************************************************/
  2249. void SwapCall(void)
  2250. {
  2251.     /*----------------------------------------------------------------*/
  2252.     /* Local Variables                                                */
  2253.     /*----------------------------------------------------------------*/
  2255.     /*----------------------------------------------------------------*/
  2256.     /* Code Body                                                      */
  2257.     /*----------------------------------------------------------------*/
  2258.     OutgoingProcessCMEvent(CM_KB_SWAPREQ, (void*)NULL);
  2259. }
  2262. /*****************************************************************************
  2263.  * FUNCTION
  2264.  *  SwapReqSucess
  2265.  * DESCRIPTION
  2266.  *  Helper function to Generate CM known Stack Event CM_PS_SWAPSUC
  2267.  *  with the Structure containing NULL.
  2268.  *  
  2269.  *  We are assuming that the protocol stack sends the Sucess response for the Swap request
  2270.  *  without any structure.
  2271.  * PARAMETERS
  2272.  *  MsgStruct       [?]         
  2273.  *  This(?)         [IN]        Contains Null)
  2274.  * RETURNS
  2275.  *  void
  2276.  *****************************************************************************/
  2277. void SwapReqSucess(void *MsgStruct)
  2278. {
  2279.     /*----------------------------------------------------------------*/
  2280.     /* Local Variables                                                */
  2281.     /*----------------------------------------------------------------*/
  2282.     U16 result;
  2284.     /*----------------------------------------------------------------*/
  2285.     /* Code Body                                                      */
  2286.     /*----------------------------------------------------------------*/
  2287.     if (CheckChldRequestSuccess(MsgStruct, &result))
  2288.     {
  2289.         PRINT_INFORMATION(("XXX - In SwapReqSucess XXXn"));
  2290.         OutgoingProcessCMEvent(CM_PS_SWAPSUC, (void*)MsgStruct);
  2291.     }
  2292.     else
  2293.     {
  2294.         PRINT_INFORMATION(("Error in swapping resuest in PS cause: %dn", result));
  2295.         SetProtocolEventHandler(PsCBackNetworkCallDropped, PRT_NWRK_CALL_RELEASE);
  2296.         ResetSwapFlag();
  2297.         OutgoingProcessCMFailureEvent(CM_PS_SWAPSUC, result);
  2298.     }
  2299. }
  2302. /*****************************************************************************
  2303.  * FUNCTION
  2304.  *  ConferenceCall
  2305.  * DESCRIPTION
  2306.  *  Helper function to generate Keybrd Event CM_KB_CONFREQ with the NULL structure.
  2307.  *  
  2308.  *  This invokes the function to process the CM_KB_CONFREQ event in the state m/c.
  2309.  * PARAMETERS
  2310.  *  void
  2311.  * RETURNS
  2312.  *  void
  2313.  *****************************************************************************/
  2314. void ConferenceCall(void)
  2315. {
  2316.     /*----------------------------------------------------------------*/
  2317.     /* Local Variables                                                */
  2318.     /*----------------------------------------------------------------*/
  2320.     /*----------------------------------------------------------------*/
  2321.     /* Code Body                                                      */
  2322.     /*----------------------------------------------------------------*/
  2323.     if ((GetTotalActiveCallCount() < MAX_HOLD) &&
  2324.         (GetTotalHoldCallCount() < MAX_HOLD) && ((GetTotalActiveCallCount() > 0 && GetTotalHoldCallCount() > 0)))
  2325.     {
  2326.         OutgoingProcessCMEvent(CM_KB_CONFREQ, (void*)NULL);
  2327.     }
  2328.     else
  2329.     {
  2330.         ShowCallManagementErrorMessage(NO_ACTIVE_CALL);
  2331.     }
  2332. }
  2335. /*****************************************************************************
  2336.  * FUNCTION
  2337.  *  ConfReqSucess
  2338.  * DESCRIPTION
  2339.  *  Helper function to Generate CM known Stack Event CM_PS_CONFSUC
  2340.  *  with the Structure containing NULL.
  2341.  *  
  2342.  *  We are assuming that the protocol stack sends the Sucess response for the Conference request
  2343.  *  without any structure.
  2344.  * PARAMETERS
  2345.  *  MsgStruct       [?]         
  2346.  *  This(?)         [IN]        Contains Null)
  2347.  * RETURNS
  2348.  *  void
  2349.  *****************************************************************************/
  2350. void ConfReqSucess(void *MsgStruct)
  2351. {
  2352.     /*----------------------------------------------------------------*/
  2353.     /* Local Variables                                                */
  2354.     /*----------------------------------------------------------------*/
  2355.     U16 result;
  2357.     /*----------------------------------------------------------------*/
  2358.     /* Code Body                                                      */
  2359.     /*----------------------------------------------------------------*/
  2360.     if (CheckChldRequestSuccess(MsgStruct, &result))
  2361.     {
  2362.         PRINT_INFORMATION(("XXX - In ConfReqSucess XXXn"));
  2363.         OutgoingProcessCMEvent(CM_PS_CONFSUC, (void*)MsgStruct);
  2364.     }
  2365.     else
  2366.     {
  2367.         PRINT_INFORMATION(("Error in Conferencing resquest in PS cause: %dn", result));
  2368.         ResetConfFlag();
  2369.         SetProtocolEventHandler(PsCBackNetworkCallDropped, PRT_NWRK_CALL_RELEASE);
  2370.         OutgoingProcessCMFailureEvent(CM_PS_CONFSUC, result);
  2371.     }
  2372. }
  2375. /*****************************************************************************
  2376.  * FUNCTION
  2377.  *  SplitCall
  2378.  * DESCRIPTION
  2379.  *  Helper function to generate Keybrd Event CM_KB_SPLITREQ with the NULL structure.
  2380.  *  
  2381.  *  This invokes the function to process the CM_KB_SPLITREQ event in the state m/c.
  2382.  * PARAMETERS
  2383.  *  CallHandle      [IN]        
  2384.  * RETURNS
  2385.  *  void
  2386.  *****************************************************************************/
  2387. void SplitCall(CM_CALL_HANDLE CallHandle)
  2388. {
  2389.     /*----------------------------------------------------------------*/
  2390.     /* Local Variables                                                */
  2391.     /*----------------------------------------------------------------*/
  2393.     /*----------------------------------------------------------------*/
  2394.     /* Code Body                                                      */
  2395.     /*----------------------------------------------------------------*/
  2396.     OutgoingProcessCMEvent(CM_KB_SPLITREQ, &CallHandle);
  2397. }
  2400. /*****************************************************************************
  2401.  * FUNCTION
  2402.  *  SplitReqSucess
  2403.  * DESCRIPTION
  2404.  *  Helper function to Generate CM known Stack Event CM_PS_SPLITSUC
  2405.  *  with the Structure containing NULL.
  2406.  *  
  2407.  *  We are assuming that the protocol stack sends the Sucess response for the Split
  2408.  *  request without any structure.
  2409.  * PARAMETERS
  2410.  *  MsgStruct       [?]         
  2411.  *  This(?)         [IN]        Contains Null)
  2412.  * RETURNS
  2413.  *  void
  2414.  *****************************************************************************/
  2415. void SplitReqSucess(void *MsgStruct)
  2416. {
  2417.     /*----------------------------------------------------------------*/
  2418.     /* Local Variables                                                */
  2419.     /*----------------------------------------------------------------*/
  2420.     U16 result;
  2422.     /*----------------------------------------------------------------*/
  2423.     /* Code Body                                                      */
  2424.     /*----------------------------------------------------------------*/
  2425.     if (CheckChldRequestSuccess(MsgStruct, &result))
  2426.     {
  2427.         PRINT_INFORMATION(("XXX - In SplitReqSucess XXXn"));
  2428.         OutgoingProcessCMEvent(CM_PS_SPLITSUC, (void*)MsgStruct);
  2429.     }
  2430.     else
  2431.     {
  2432.         PRINT_INFORMATION(("Error in Split in protocol stack cause %d", result));
  2433.         SetProtocolEventHandler(PsCBackNetworkCallDropped, PRT_NWRK_CALL_RELEASE);
  2434.         ResetSplitFlag();
  2435.         OutgoingProcessCMFailureEvent(CM_PS_SPLITSUC, result);
  2436.     }
  2437. }
  2440. /*****************************************************************************
  2441.  * FUNCTION
  2442.  *  TransferCall
  2443.  * DESCRIPTION
  2444.  *  This function performs Explicit Call Transfer.
  2445.  * PARAMETERS
  2446.  *  void
  2447.  * RETURNS
  2448.  *  void
  2449.  *****************************************************************************/
  2450. void TransferCall(void)
  2451. {
  2452.     /*----------------------------------------------------------------*/
  2453.     /* Local Variables                                                */
  2454.     /*----------------------------------------------------------------*/
  2456.     /*----------------------------------------------------------------*/
  2457.     /* Code Body                                                      */
  2458.     /*----------------------------------------------------------------*/
  2459.     OutgoingProcessCMEvent(CM_KB_ECT_REQ, (void*)NULL);
  2460. }
  2463. /*****************************************************************************
  2464.  * FUNCTION
  2465.  *  EctReqSucess
  2466.  * DESCRIPTION
  2467.  *  Helper function to Generate CM known Stack Event CM_PS_SPLITSUC
  2468.  *  with the Structure containing NULL.
  2469.  *  
  2470.  *  We are assuming that the protocol stack sends the Sucess response for the Split
  2471.  *  request without any structure.
  2472.  * PARAMETERS
  2473.  *  MsgStruct       [?]         
  2474.  *  This(?)         [IN]        Contains Null)
  2475.  * RETURNS
  2476.  *  void
  2477.  *****************************************************************************/
  2478. void EctReqSucess(void *MsgStruct)
  2479. {
  2480.     /*----------------------------------------------------------------*/
  2481.     /* Local Variables                                                */
  2482.     /*----------------------------------------------------------------*/
  2483.     U16 result;
  2485.     /*----------------------------------------------------------------*/
  2486.     /* Code Body                                                      */
  2487.     /*----------------------------------------------------------------*/
  2488.     if (CheckChldRequestSuccess(MsgStruct, &result))
  2489.     {
  2490.         PRINT_INFORMATION(("XXX - In EctReqSucess XXXn"));
  2491.         OutgoingProcessCMEvent(CM_PS_ECT_SUC, (void*)MsgStruct);
  2492.     }
  2493.     else
  2494.     {
  2495.         PRINT_INFORMATION(("Error in ECT in protocol stack cause %d", result));
  2496.         SetProtocolEventHandler(PsCBackNetworkCallDropped, PRT_NWRK_CALL_RELEASE);
  2497.         ResetEctFlag();
  2498.         OutgoingProcessCMFailureEvent(CM_PS_ECT_SUC, result);
  2499.     }
  2500. }
  2503. /*****************************************************************************
  2504.  * FUNCTION
  2505.  *  EnterScreenAndHandleDigit
  2506.  * DESCRIPTION
  2507.  *  Helper function to initiate sending DTMF tone and
  2508.  *  display screen
  2509.  * PARAMETERS
  2510.  *  void
  2511.  * RETURNS
  2512.  *  void
  2513.  *****************************************************************************/
  2514. void EnterScreenAndHandleDigit(void)
  2515. {
  2516.     /*----------------------------------------------------------------*/
  2517.     /* Local Variables                                                */
  2518.     /*----------------------------------------------------------------*/
  2520.     /*----------------------------------------------------------------*/
  2521.     /* Code Body                                                      */
  2522.     /*----------------------------------------------------------------*/
  2523.     ClearDtmfBuf();
  2524.     SetCMScrnFlag(FALSE);
  2526.     if ((GetTotalActiveCallCount() > 0 || GetCurrentState() == CM_OUTGOING_STATE) && (GetDTMFFlag()))
  2527.     {
  2528.         EntryScrDisplayDialedDigits();
  2529.         HandleDTMFScreenDigits();
  2530.     }
  2531.     else
  2532.     {
  2533.         EntryScrDisplayDialedDigits();
  2534.         UpdateDialedDigitDisplay();
  2535.     }
  2536. }
  2539. /*****************************************************************************
  2540.  * FUNCTION
  2541.  *  EntryScrDisplayDialedDigits
  2542.  * DESCRIPTION
  2543.  *  Shows the dialled digits in dtmf
  2544.  * PARAMETERS
  2545.  *  void
  2546.  * RETURNS
  2547.  *  void
  2548.  *****************************************************************************/
  2549. void EntryScrDisplayDialedDigits(void)
  2550. {
  2551.     /*----------------------------------------------------------------*/
  2552.     /* Local Variables                                                */
  2553.     /*----------------------------------------------------------------*/
  2554.     U8 *historyBuffer;
  2555.     U16 lskStrShow = STR_GLOBAL_SAVE;
  2556.     U8 *tmp = GetCurrInputBuffer(DTMF_SCR_DISPLAY_ID);
  2558.     /*----------------------------------------------------------------*/
  2559.     /* Code Body                                                      */
  2560.     /*----------------------------------------------------------------*/
  2561.     EntryNewScreen(DTMF_SCR_DISPLAY_ID, ExitScrDisplayDialedDigits, NULL, NULL);
  2563.     cm_p->history_info.IsSave = TRUE;
  2565.     if (tmp)
  2566.     {
  2567.         pfnUnicodeStrcpy((S8*) UnicodeDTMFPadCallBuffer, (S8*) tmp);
  2568.     }
  2569.     else
  2570.     {
  2571.   memset (UnicodeDTMFPadCallBuffer, 0, sizeof (UnicodeDTMFPadCallBuffer));
  2572.     }
  2574.     historyBuffer = GetCurrGuiBuffer(DTMF_SCR_DISPLAY_ID);
  2576.     /* delete any previous intance of screen if present */
  2577.     if (GetCurrScrnId() != DTMF_SCR_DISPLAY_ID)
  2578.     {
  2579.         DeleteScreenIfPresent(DTMF_SCR_DISPLAY_ID);
  2580.     }
  2582.     if ((GetCurrScrnId() == SCR1001_CM_OUTGOINGCALLSCREEN && GetTotalCallCount() == 1) || EmergencyCallPresent())
  2583.     {
  2584.         lskStrShow = 0;
  2585.         SetNoSave();
  2586.     }
  2588.     if (lskStrShow != 0)
  2589.     {
  2590.         RegisterInputBoxEmptyFunction(DialDigitScreenEmpty);
  2591.         RegisterInputBoxNotEmptyFunction(DialDigitScreenNotEmpty);
  2592.     }
  2593.     else
  2594.     {
  2595.         /* no icon, no center key */
  2596.     #if ( (defined  __MMI_WGUI_CSK_ENABLE__) && defined (__MMI_TOUCH_SCREEN__) )
  2597.     #if defined  (__MMI_TOUCH_DIAL_SCREEN_WITH_FUNCTION__)
  2598.         SetDialingKeypadCallHandler(UI_dummy_function);
  2599. SetDialingKeypadIPCallHandler(UI_dummy_function);         //KP Jerry add on 2006-11-13
  2600.         SetDialingKeypadPhonebookHandler(UI_dummy_function);
  2601.     #else /* defined  (__MMI_TOUCH_DIAL_SCREEN_WITH_FUNCTION__) */ 
  2602.      ResetCenterSoftkey();
  2603.     #endif /* defined  (__MMI_TOUCH_DIAL_SCREEN_WITH_FUNCTION__) */ 
  2604.     #endif /* ( (defined  __MMI_WGUI_CSK_ENABLE__) && defined (__MMI_TOUCH_SCREEN__) ) */ 
  2605.     }
  2607.     ShowCategory16Screen(
  2608.         lskStrShow,
  2609.         0,
  2610.         STR_GLOBAL_BACK,
  2611.         IMG_GLOBAL_BACK,
  2612.         (PU8) UnicodeDTMFPadCallBuffer,
  2613.         MAX_DIGIT,
  2614.         historyBuffer);
  2615.     wgui_save_key_handlers();
  2617.     /* LSK, RSK */
  2618.     SetCategory16RightSoftkeyFunction(CheckBeforeGoBackHistory, KEY_EVENT_UP);
  2620.     if (lskStrShow != 0)
  2621.     {
  2622.         SetLeftSoftkeyFunction(CallMgmtSavePhoneBook, KEY_EVENT_UP);
  2623.     }
  2625.     /* SEND, END key */
  2626.     if (GetCurrentState() == CM_INCOMING_STATE)
  2627.     {
  2628.         if (GetTotalCallCount() == 1)
  2629.         {
  2630.             SetKeyHandler(KbCBackCallIncomingRejected, KEY_END, KEY_EVENT_DOWN);
  2631.         }
  2632.         else
  2633.         {
  2634.         #ifdef __MMI_CLAMSHELL__
  2635.             SetKeyHandler(KbCBackCallIncomingRejected, KEY_END, KEY_EVENT_DOWN);
  2636.         #else 
  2637.             SetKeyHandler(KbCBackEndAllCallsExceptIncoming, KEY_END, KEY_EVENT_DOWN);
  2638.         #endif 
  2639.         }
  2641.     }
  2642.     else if (CM_IDLE_STATE != GetCurrentState())
  2643.     {
  2644.         SetKeyHandler(HangupAll, KEY_END, KEY_EVENT_DOWN);
  2645.     }
  2647.     /* group key */
  2648.     if ((GetTotalActiveCallCount() > 0 || GetCurrentState() == CM_OUTGOING_STATE) && (GetDTMFFlag()))
  2649.     {
  2650.         SetGroupKeyHandler(HandleDTMFScreenDigits, (PU16) CMIdleScreenDigits, MAX_CM_SCREEN_DIGITS - 1, KEY_EVENT_DOWN);
  2651.         SetGroupKeyHandler(HandleDTMFScreenStopTone, (PU16) CMIdleScreenDigits, MAX_CM_SCREEN_DIGITS - 1, KEY_EVENT_UP);
  2652.         SetGroupKeyHandler(NULL, (PU16) CMIdleScreenDigits, MAX_CM_SCREEN_DIGITS - 1, KEY_REPEAT);
  2653.     }
  2654.     else
  2655.     {
  2656.         SetGroupKeyHandler(
  2657.             UpdateDialedDigitDisplay,
  2658.             (PU16) CMIdleScreenDigits,
  2659.             MAX_CM_SCREEN_DIGITS - 1,
  2660.             KEY_EVENT_DOWN);
  2661.         SetGroupKeyHandler(NULL, (PU16) CMIdleScreenDigits, MAX_CM_SCREEN_DIGITS - 1, KEY_REPEAT);
  2662.     }
  2664.     /* side key */
  2665.     SetSideVolumeKeysForCM();
  2666. }
  2669. /*****************************************************************************
  2670.  * FUNCTION
  2671.  *  ExitScrDisplayDialedDigits
  2672.  * DESCRIPTION
  2673.  *  Shows the dialed digits in dtmf
  2674.  * PARAMETERS
  2675.  *  void
  2676.  * RETURNS
  2677.  *  void
  2678.  *****************************************************************************/
  2679. void ExitScrDisplayDialedDigits(void)
  2680. {
  2681.     /*----------------------------------------------------------------*/
  2682.     /* Local Variables                                                */
  2683.     /*----------------------------------------------------------------*/
  2685.     /*----------------------------------------------------------------*/
  2686.     /* Code Body                                                      */
  2687.     /*----------------------------------------------------------------*/
  2688.     if (cm_p->history_info.IsSave)
  2689.     {
  2690.         history Scr1001;
  2692.         Scr1001.scrnID = DTMF_SCR_DISPLAY_ID;
  2693.         Scr1001.entryFuncPtr = EntryScrDisplayDialedDigits;
  2694.         pfnUnicodeStrcpy((S8*) Scr1001.inputBuffer, (S8*) UnicodeDTMFPadCallBuffer);
  2695.         GetCategoryHistory(Scr1001.guiBuffer);
  2696.         AddHistory(Scr1001);
  2697.     }
  2698.     else
  2699.     {
  2700.         cm_p->history_info.IsSave = TRUE;
  2701.     }
  2703.     if (GetDTMFKeyUpFlag() == TRUE)
  2704.     {
  2705.         HandleDTMFScreenStopTone();
  2706.     }
  2708. #if ( (defined  __MMI_WGUI_CSK_ENABLE__) && defined (__MMI_TOUCH_SCREEN__) )
  2709. #if defined  (__MMI_TOUCH_DIAL_SCREEN_WITH_FUNCTION__)
  2710.     SetDialingKeypadCallHandler(UI_dummy_function);
  2711. SetDialingKeypadIPCallHandler(UI_dummy_function);       //KP Jerry add on 2006-11-13
  2712. #else 
  2713.     ResetCenterSoftkey();
  2714. #endif 
  2715. #endif /* ( (defined  __MMI_WGUI_CSK_ENABLE__) && defined (__MMI_TOUCH_SCREEN__) ) */ 
  2717. }
  2720. /*****************************************************************************
  2721.  * FUNCTION
  2722.  *  DialDigitScreenEmpty
  2723.  * DESCRIPTION
  2724.  *  register function when screen is empty for call deflection
  2725.  * PARAMETERS
  2726.  *  void
  2727.  * RETURNS
  2728.  *  void
  2729.  *****************************************************************************/
  2730. void DialDigitScreenEmpty(void)
  2731. {
  2732.     /*----------------------------------------------------------------*/
  2733.     /* Local Variables                                                */
  2734.     /*----------------------------------------------------------------*/
  2736.     /*----------------------------------------------------------------*/
  2737.     /* Code Body                                                      */
  2738.     /*----------------------------------------------------------------*/
  2739.     ClearKeyHandler(KEY_SEND, KEY_EVENT_UP);
  2741. #if ( (defined  __MMI_WGUI_CSK_ENABLE__) && defined (__MMI_TOUCH_SCREEN__) )
  2742. #if defined (__MMI_TOUCH_DIAL_SCREEN_WITH_FUNCTION__)
  2743.     /* grey call, phb icon */
  2744.     SetDialingKeypadCallHandler(UI_dummy_function);
  2745.     SetDialingKeypadIPCallHandler(UI_dummy_function);//KP Jerry add on 2007-4-24
  2746.     SetDialingKeypadPhonebookHandler(mmi_phb_list_enter_first_from_active_call);
  2747. #else /* defined (__MMI_TOUCH_DIAL_SCREEN_WITH_FUNCTION__) */ 
  2748.     SetCenterSoftkeyFunction(UI_dummy_function, KEY_EVENT_UP);
  2749. #endif /* defined (__MMI_TOUCH_DIAL_SCREEN_WITH_FUNCTION__) */ 
  2750. #endif /* ( (defined  __MMI_WGUI_CSK_ENABLE__) && defined (__MMI_TOUCH_SCREEN__) ) */ 
  2751. }
  2754. /*****************************************************************************
  2755.  * FUNCTION
  2756.  *  DialDigitScreenNotEmpty
  2757.  * DESCRIPTION
  2758.  *  register function when screen is not empty for call deflection
  2759.  * PARAMETERS
  2760.  *  void
  2761.  * RETURNS
  2762.  *  void
  2763.  *****************************************************************************/
  2764. void DialDigitScreenNotEmpty(void)
  2765. {
  2766.     /*----------------------------------------------------------------*/
  2767.     /* Local Variables                                                */
  2768.     /*----------------------------------------------------------------*/
  2770.     /*----------------------------------------------------------------*/
  2771.     /* Code Body                                                      */
  2772.     /*----------------------------------------------------------------*/
  2773.     SetKeyHandler(MakeCallFromDTMFScr, KEY_SEND, KEY_EVENT_DOWN);
  2775. #if ( (defined  __MMI_WGUI_CSK_ENABLE__) && defined (__MMI_TOUCH_SCREEN__) )
  2776. #if defined (__MMI_TOUCH_DIAL_SCREEN_WITH_FUNCTION__)
  2777.     SetDialingKeypadCallHandler(MakeCallFromDTMFScr);
  2778.     SetDialingKeypadIPCallHandler(MakeIPCallFromDTMFScr);     //KP Jerry add on 2007-4-25
  2779.     SetDialingKeypadPhonebookHandler(mmi_phb_list_enter_first_from_active_call);
  2780. #else /* defined (__MMI_TOUCH_DIAL_SCREEN_WITH_FUNCTION__) */ 
  2781.     SetCenterSoftkeyFunction(MakeCallFromDTMFScr, KEY_EVENT_UP);
  2782. #endif /* defined (__MMI_TOUCH_DIAL_SCREEN_WITH_FUNCTION__) */ 
  2783. #endif /* ( (defined  __MMI_WGUI_CSK_ENABLE__) && defined (__MMI_TOUCH_SCREEN__) ) */ 
  2784. }
  2786. /**************************************************************
  2788.    FUNCTION NAME     : StoreAndKeepKeyCode
  2790.    PURPOSE           : Helper to store current key press
  2792.    INPUT PARAMETERS  : void
  2794.    OUTPUT PARAMETERS : nil
  2796.    RETURNS           : void
  2798.    REMARKS           : This is needed since the key repeat event rewrites it in the framework
  2800. **************************************************************/
  2801. /*
  2802.  * void StoreAndKeepKeyCode (U16 keycode, U16 keytype)
  2803.  * {
  2804.  * curKeyCode = keycode;
  2805.  * curKeyType = keytype;
  2806.  * }
  2807.  */
  2810. /*****************************************************************************
  2811.  * FUNCTION
  2812.  *  InCallSSCParsing
  2813.  * DESCRIPTION
  2814.  *  Helper function to check if the string is IMEI
  2815.  * PARAMETERS
  2816.  *  void
  2817.  * RETURNS
  2818.  *  void
  2819.  *****************************************************************************/
  2820. void InCallSSCParsing(void)
  2821. {
  2822.     /*----------------------------------------------------------------*/
  2823.     /* Local Variables                                                */
  2824.     /*----------------------------------------------------------------*/
  2825.     S8 stringIMEI[20];
  2826.     S8 newstringIMEI[MAX_DIGITS_USSD * ENCODING_LENGTH];
  2828.     /*----------------------------------------------------------------*/
  2829.     /* Code Body                                                      */
  2830.     /*----------------------------------------------------------------*/
  2831.     strcpy((S8*) stringIMEI, "*#06#");
  2832.     AnsiiToUnicodeString((PS8) newstringIMEI, (PS8) stringIMEI);
  2834.     if (pfnUnicodeStrcmp((S8*) newstringIMEI, (S8*) UnicodeDTMFPadCallBuffer) == 0)
  2835.     {
  2836.         SSCHandleIMEI();
  2837.         return;
  2838.     }
  2839. }
  2842. /*****************************************************************************
  2843.  * FUNCTION
  2844.  *  is_valid_dtmf_key
  2845.  * DESCRIPTION
  2846.  *  Helper function to make an send dtmf tones over the network or
  2847.  *  dial a call in case of user clicking send
  2848.  * PARAMETERS
  2849.  *  keycode     [IN]        
  2850.  * RETURNS
  2851.  *  void
  2852.  *****************************************************************************/
  2853. pBOOL is_valid_dtmf_key(U16 keycode)
  2854. {
  2855.     /*----------------------------------------------------------------*/
  2856.     /* Local Variables                                                */
  2857.     /*----------------------------------------------------------------*/
  2858.     U8 i;
  2860.     /*----------------------------------------------------------------*/
  2861.     /* Code Body                                                      */
  2862.     /*----------------------------------------------------------------*/
  2863.     for (i = 0; i < MAX_CM_SCREEN_DIGITS; i++)
  2864.     {
  2865.         if (keycode == CMIdleScreenDigits[i])
  2866.         {
  2867.             return MMI_TRUE;
  2868.         }
  2869.     }
  2870.     return MMI_FALSE;
  2871. }
  2874. /*****************************************************************************
  2875.  * FUNCTION
  2876.  *  HandleDTMFScreenDigits
  2877.  * DESCRIPTION
  2878.  *  Helper function to make an send dtmf tones over the network or
  2879.  *  dial a call in case of user clicking send
  2880.  * PARAMETERS
  2881.  *  void
  2882.  * RETURNS
  2883.  *  void
  2884.  *****************************************************************************/
  2885. void HandleDTMFScreenDigits(void)
  2886. {
  2887.     /*----------------------------------------------------------------*/
  2888.     /* Local Variables                                                */
  2889.     /*----------------------------------------------------------------*/
  2890.     U16 keycode, keytype;
  2892.     /*----------------------------------------------------------------*/
  2893.     /* Code Body                                                      */
  2894.     /*----------------------------------------------------------------*/
  2895.     PRINT_INFORMATION(("n **** HandleDTMFScreenDigitsn"));
  2896.     PRINT_INFORMATION(("n **** Sending DTMF Tonen"));
  2897.     /* SetProtocolEventHandler(DtmfSendSuccess, PRT_DTMF_START_RES); */
  2899.     SetDTMFKeyUpFlag(TRUE);
  2901.     GetkeyInfo(&keycode, &keytype);
  2902.     /* StoreAndKeepKeyCode(keycode, keytype); */
  2904.     /* enter dial pad from New Call menu item */
  2905.     if (!IsScreenPresent(SCR1003_CM_ACTIVECALLOPTIONS) && is_valid_dtmf_key(keycode))
  2906.     {
  2907.         MuteOnMicrophone();
  2908.     #ifdef __MMI_WGUI_CSK_ENABLE__
  2909.         if (keycode != KEY_CSK)
  2910.     #endif 
  2911.             MakePsSendDTMFTone(&keycode);
  2912.     }
  2913.     wgui_execute_key_handler(keycode, keytype);
  2914. }
  2917. /*****************************************************************************
  2918.  * FUNCTION
  2919.  *  UpdateDialedDigitDisplay
  2920.  * DESCRIPTION
  2921.  *  Helper function to update dial screen with only digits
  2922.  * PARAMETERS
  2923.  *  void
  2924.  * RETURNS
  2925.  *  void
  2926.  *****************************************************************************/
  2927. void UpdateDialedDigitDisplay(void)
  2928. {
  2929.     /*----------------------------------------------------------------*/
  2930.     /* Local Variables                                                */
  2931.     /*----------------------------------------------------------------*/
  2932.     U16 keycode, keytype;
  2934.     /*----------------------------------------------------------------*/
  2935.     /* Code Body                                                      */
  2936.     /*----------------------------------------------------------------*/
  2937.     GetkeyInfo(&keycode, &keytype);
  2938.     /* StoreAndKeepKeyCode(keycode, keytype); */
  2939.     wgui_execute_key_handler(keycode, keytype);
  2940.     HandleDisplayDialedDigits();
  2941.     InCallSSCParsing();
  2942. }
  2945. /*****************************************************************************
  2946.  * FUNCTION
  2947.  *  HandleDTMFScreenStopTone
  2948.  * DESCRIPTION
  2949.  *  Helper function to make an send dtmf tones over the network or
  2950.  *  dial a call in case of user clicking send
  2951.  * PARAMETERS
  2952.  *  void
  2953.  * RETURNS
  2954.  *  void
  2955.  *****************************************************************************/
  2956. void HandleDTMFScreenStopTone(void)
  2957. {
  2958.     /*----------------------------------------------------------------*/
  2959.     /* Local Variables                                                */
  2960.     /*----------------------------------------------------------------*/
  2961.     U16 keycode, keytype;
  2963.     /*----------------------------------------------------------------*/
  2964.     /* Code Body                                                      */
  2965.     /*----------------------------------------------------------------*/
  2966.     PRINT_INFORMATION(("n **** HandleDTMFScreenStopTonen"));
  2968.     MakePsStopDTMFTone();
  2969.     if (IsPhoneInMute() == MMI_FALSE)
  2970.     {
  2971.         MuteOffMicrophone();
  2972.     }
  2973.     HandleDisplayDialedDigits();
  2974.     SetDTMFKeyUpFlag(FALSE);
  2976.     GetkeyInfo(&keycode, &keytype);
  2977.     /* StoreAndKeepKeyCode(keycode, keytype); */
  2978.     wgui_execute_key_handler(keycode, keytype);
  2979.     InCallSSCParsing();
  2980. }
  2983. /*****************************************************************************
  2984.  * FUNCTION
  2985.  *  HandleDisplayDialedDigits
  2986.  * DESCRIPTION
  2987.  *  Handles drawing of category screen and display digits
  2988.  * PARAMETERS
  2989.  *  void
  2990.  * RETURNS
  2991.  *  void
  2992.  *****************************************************************************/
  2993. void HandleDisplayDialedDigits(void)
  2994. {
  2995.     /*----------------------------------------------------------------*/
  2996.     /* Local Variables                                                */
  2997.     /*----------------------------------------------------------------*/
  2999.     /*----------------------------------------------------------------*/
  3000.     /* Code Body                                                      */
  3001.     /*----------------------------------------------------------------*/
  3002.     if ((GetTotalActiveCallCount() > 0 || GetCurrentState() == CM_OUTGOING_STATE) && (GetDTMFFlag()))
  3003.     {
  3004.         SetGroupKeyHandler(HandleDTMFScreenDigits, (PU16) CMIdleScreenDigits, MAX_CM_SCREEN_DIGITS - 1, KEY_EVENT_DOWN);
  3005.         SetGroupKeyHandler(HandleDTMFScreenStopTone, (PU16) CMIdleScreenDigits, MAX_CM_SCREEN_DIGITS - 1, KEY_EVENT_UP);
  3006.         SetGroupKeyHandler(MMI_dummy_function, (PU16) CMIdleScreenDigits, MAX_CM_SCREEN_DIGITS - 1, KEY_REPEAT);
  3007.     }
  3008.     else
  3009.     {
  3010.         /* wgui_execute_key_handler(curKeyCode, curKeyType); */
  3011.         SetGroupKeyHandler(
  3012.             UpdateDialedDigitDisplay,
  3013.             (PU16) CMIdleScreenDigits,
  3014.             MAX_CM_SCREEN_DIGITS - 1,
  3015.             KEY_EVENT_DOWN);
  3016.     }
  3018. if (GetCurrentState() != CM_OUTGOING_STATE && !EmergencyCallPresent())
  3019. {
  3020.     SetKeyHandler(MakeCallFromDTMFScr, KEY_SEND, KEY_EVENT_DOWN);
  3021. }
  3022.     if (GetCurrentState() == CM_INCOMING_STATE)
  3023.     {
  3024.         if (GetTotalCallCount() == 1)
  3025.         {
  3026.             SetKeyHandler(KbCBackCallIncomingRejected, KEY_END, KEY_EVENT_DOWN);
  3027.         }
  3028.         else
  3029.         {
  3030.         #ifdef __MMI_CLAMSHELL__
  3031.             SetKeyHandler(KbCBackCallIncomingRejected, KEY_END, KEY_EVENT_DOWN);
  3032.         #else 
  3033.             SetKeyHandler(KbCBackEndAllCallsExceptIncoming, KEY_END, KEY_EVENT_DOWN);
  3034.         #endif 
  3035.         }
  3037.     }
  3038.     else if (CM_IDLE_STATE == GetCurrentState())
  3039.     {
  3040.         SetKeyHandler(CheckBeforeGoBackHistory, KEY_END, KEY_EVENT_DOWN);
  3041.     }
  3042.     else
  3043.     {
  3044.         SetKeyHandler(HangupAll, KEY_END, KEY_EVENT_DOWN);
  3045.     }
  3047.     RegisterCategory16NavigationKeys();
  3049.     SetLeftSoftkeyFunction(CallMgmtSavePhoneBook, KEY_EVENT_UP);
  3050.     SetCategory16RightSoftkeyFunction(CheckBeforeGoBackHistory, KEY_EVENT_UP);
  3052.     SetSideVolumeKeysForCM();
  3053. }
  3056. /*****************************************************************************
  3057.  * FUNCTION
  3058.  *  MakeCallFromDTMFScr
  3059.  * DESCRIPTION
  3060.  *  Clear the DTMF buffer
  3061.  * PARAMETERS
  3062.  *  void
  3063.  * RETURNS
  3064.  *  void
  3065.  *****************************************************************************/
  3066. void MakeCallFromDTMFScr(void)
  3067. {
  3068. #ifdef __MMI_TOUCH_DIAL_SCREEN__
  3069.     /*----------------------------------------------------------------*/
  3070.     /* Local Variables                                                */
  3071.     /*----------------------------------------------------------------*/
  3073.     /*----------------------------------------------------------------*/
  3074.     /* Code Body                                                      */
  3075.     /*----------------------------------------------------------------*/
  3076.     /* no input */
  3077.     if (UnicodeDTMFPadCallBuffer[0] == 0 && UnicodeDTMFPadCallBuffer[1] == 0)
  3078.     {
  3079.         return;
  3080.     }
  3081. #endif /* __MMI_TOUCH_DIAL_SCREEN__ */ 
  3082.     SetDialedDigitCalledFlag(TRUE);
  3083.     MakeCall(UnicodeDTMFPadCallBuffer);
  3084. }
  3086. //KP Jerry add on 2007-4-25 start
  3087. void MakeIPCallFromDTMFScr(void)
  3088. {
  3089. #ifdef __MMI_TOUCH_DIAL_SCREEN__
  3090.     /*----------------------------------------------------------------*/
  3091.     /* Local Variables                                                */
  3092.     /*----------------------------------------------------------------*/
  3094.     /*----------------------------------------------------------------*/
  3095.     /* Code Body                                                      */
  3096.     /*----------------------------------------------------------------*/
  3097.     /* no input */
  3098.     if (UnicodeDTMFPadCallBuffer[0] == 0 && UnicodeDTMFPadCallBuffer[1] == 0)
  3099.     {
  3100.         return;
  3101.     }
  3102. #endif /* __MMI_TOUCH_DIAL_SCREEN__ */ 
  3103.     SetDialedDigitCalledFlag(TRUE);
  3104.     SetTempUseIPNumber(TRUE);
  3105.     MakeCall(UnicodeDTMFPadCallBuffer);
  3106. }
  3107. //KP Jerry add on 2007-4-25 end
  3109. /*****************************************************************************
  3110.  * FUNCTION
  3111.  *  CallMgmtSavePhoneBook
  3112.  * DESCRIPTION
  3113.  *  
  3114.  * PARAMETERS
  3115.  *  void
  3116.  * RETURNS
  3117.  *  void
  3118.  *****************************************************************************/
  3119. void CallMgmtSavePhoneBook(void)
  3120. {
  3121.     /*----------------------------------------------------------------*/
  3122.     /* Local Variables                                                */
  3123.     /*----------------------------------------------------------------*/
  3125.     /*----------------------------------------------------------------*/
  3126.     /* Code Body                                                      */
  3127.     /*----------------------------------------------------------------*/
  3128.     SetCMScrnFlag(FALSE);
  3129.     SaveNumberFromIdleScrn(UnicodeDTMFPadCallBuffer, 0);
  3130. }
  3133. /*****************************************************************************
  3134.  * FUNCTION
  3135.  *  ClearDtmfBuf
  3136.  * DESCRIPTION
  3137.  *  Clear the DTMF buffer
  3138.  * PARAMETERS
  3139.  *  void
  3140.  * RETURNS
  3141.  *  void
  3142.  *****************************************************************************/
  3143. void ClearDtmfBuf(void)
  3144. {
  3145.     /*----------------------------------------------------------------*/
  3146.     /* Local Variables                                                */
  3147.     /*----------------------------------------------------------------*/
  3149.     /*----------------------------------------------------------------*/
  3150.     /* Code Body                                                      */
  3151.     /*----------------------------------------------------------------*/
  3152.     memset(UnicodeDTMFPadCallBuffer, 0, sizeof(UnicodeDTMFPadCallBuffer));
  3153.     memset(DTMFPadCallBuffer, 0, sizeof(DTMFPadCallBuffer));
  3154. }
  3157. /*****************************************************************************
  3158.  * FUNCTION
  3159.  *  FillDtmfBuff
  3160.  * DESCRIPTION
  3161.  *  Fills up DTMF Buffer for access later
  3162.  * PARAMETERS
  3163.  *  buf     [IN]        
  3164.  * RETURNS
  3165.  *  void
  3166.  *****************************************************************************/
  3167. void FillDtmfBuff(PU8 buf)
  3168. {
  3169.     /*----------------------------------------------------------------*/
  3170.     /* Local Variables                                                */
  3171.     /*----------------------------------------------------------------*/
  3173.     /*----------------------------------------------------------------*/
  3174.     /* Code Body                                                      */
  3175.     /*----------------------------------------------------------------*/
  3176.     pfnUnicodeStrcpy(UnicodeDTMFPadCallBuffer, (void*)buf);
  3177. }
  3180. /*****************************************************************************
  3181.  * FUNCTION
  3182.  *  GetDtmfBuffer
  3183.  * DESCRIPTION
  3184.  *  Return the DTMF buffer
  3185.  * PARAMETERS
  3186.  *  void
  3187.  * RETURNS
  3188.  *  void
  3189.  *****************************************************************************/
  3190. PU8 GetDtmfBuffer(void)
  3191. {
  3192.     /*----------------------------------------------------------------*/
  3193.     /* Local Variables                                                */
  3194.     /*----------------------------------------------------------------*/
  3196.     /*----------------------------------------------------------------*/
  3197.     /* Code Body                                                      */
  3198.     /*----------------------------------------------------------------*/
  3199.     UnicodeToAnsii(DTMFPadCallBuffer, UnicodeDTMFPadCallBuffer);
  3200.     return (PU8) DTMFPadCallBuffer;
  3201. }
  3204. /*****************************************************************************
  3205.  * FUNCTION
  3206.  *  SetDialIndication
  3207.  * DESCRIPTION
  3208.  *  to set the dial indication flag as per argument
  3209.  * PARAMETERS
  3210.  *  truth       [IN]        
  3211.  *  TRUE(?)     [IN]        /FALSE
  3212.  * RETURNS
  3213.  *  void
  3214.  *****************************************************************************/
  3215. void SetDialIndication(pBOOL truth)
  3216. {
  3217.     /*----------------------------------------------------------------*/
  3218.     /* Local Variables                                                */
  3219.     /*----------------------------------------------------------------*/
  3221.     /*----------------------------------------------------------------*/
  3222.     /* Code Body                                                      */
  3223.     /*----------------------------------------------------------------*/
  3224.     gCheckDialIndEndOutgoing = truth;
  3225. }
  3228. /*****************************************************************************
  3229.  * FUNCTION
  3230.  *  GetDialIndication
  3231.  * DESCRIPTION
  3232.  *  To Get the dial indication flag
  3233.  * PARAMETERS
  3234.  *  void
  3235.  *  TRUE(?)     [IN]        /FALSE
  3236.  * RETURNS
  3237.  *  void
  3238.  *****************************************************************************/
  3239. pBOOL GetDialIndication(void)
  3240. {
  3241.     /*----------------------------------------------------------------*/
  3242.     /* Local Variables                                                */
  3243.     /*----------------------------------------------------------------*/
  3245.     /*----------------------------------------------------------------*/
  3246.     /* Code Body                                                      */
  3247.     /*----------------------------------------------------------------*/
  3248.     return gCheckDialIndEndOutgoing;
  3249. }
  3251. #ifdef MMI_ON_HARDWARE_P
  3252. /*****************************************************************************
  3253.  * FUNCTION
  3254.  *  MakeCallReqInd
  3255.  * DESCRIPTION
  3256.  *  Helper function to make call when PRT_MMI_MAKE_CALL_REQ_IND comes.
  3257.  * PARAMETERS
  3258.  * MsgStruct(?)       [IN]        Which needs to make the outgoing call.              
  3259.  * RETURNS
  3260.  *  void
  3261.  *****************************************************************************/
  3262. void MakeCallReqInd(void *MsgStruct)
  3263. {
  3264.     /*----------------------------------------------------------------*/
  3265.     /* Local Variables                                                */
  3266.     /*----------------------------------------------------------------*/
  3267.     
  3268.     /*----------------------------------------------------------------*/
  3269.     /* Code Body                                                      */
  3270.     /*----------------------------------------------------------------*/
  3272.     PRINT_INFORMATION(("XXX - In MakeCallReqInd XXXn"));
  3274.     MakeCall((PS8)((MMI_MAKE_CALL_REQ_IND*) MsgStruct)->strNumber);
  3275. }
  3276. #endif /* MMI_ON_HARDWARE_P */