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

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

MTK

开发平台：

C/C++

AlarmFramework.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. *****************************************************************************/
  36. /*****************************************************************************
  37.  *
  38.  * Filename:
  39.  * ---------
  40.  * AlarmFramework.c
  41.  *
  42.  * Project:
  43.  * --------
  44.  * MAUI
  45.  *
  46.  * Description:
  47.  * ------------
  48.  * This file implements alarm scheduler for alarm, to do list, schedule power on/off and theme.
  49.  *
  50.  * Author:
  51.  * -------
  52.  * -------
  53.  *
  54.  *============================================================================
  55.  *             HISTORY
  56.  * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  57.  *------------------------------------------------------------------------------
  58.  * removed!
  59.  *
  60.  * removed!
  61.  * removed!
  62.  * removed!
  63.  *
  64.  * removed!
  65.  * removed!
  66.  * removed!
  67.  *
  68.  * removed!
  69.  * removed!
  70.  * removed!
  71.  *
  72.  * removed!
  73.  * removed!
  74.  * removed!
  75.  *
  76.  * removed!
  77.  * removed!
  78.  * removed!
  79.  *
  80.  * removed!
  81.  * removed!
  82.  * removed!
  83.  *
  84.  * removed!
  85.  * removed!
  86.  * removed!
  87.  *
  88.  * removed!
  89.  * removed!
  90.  * removed!
  91.  *
  92.  * removed!
  93.  * removed!
  94.  * removed!
  95.  *
  96.  * removed!
  97.  * removed!
  98.  * removed!
  99.  *
  100.  * removed!
  101.  * removed!
  102.  * removed!
  103.  *
  104.  * removed!
  105.  * removed!
  106.  * removed!
  107.  *
  108.  * removed!
  109.  * removed!
  110.  * removed!
  111.  *
  112.  * removed!
  113.  * removed!
  114.  * removed!
  115.  *
  116.  * removed!
  117.  * removed!
  118.  * removed!
  119.  *
  120.  * removed!
  121.  * removed!
  122.  * removed!
  123.  *
  124.  * removed!
  125.  * removed!
  126.  * removed!
  127.  *
  128.  * removed!
  129.  * removed!
  130.  * removed!
  131.  *
  132.  * removed!
  133.  * removed!
  134.  * removed!
  135.  *
  136.  * removed!
  137.  * removed!
  138.  * removed!
  139.  *
  140.  * removed!
  141.  * removed!
  142.  * removed!
  143.  *
  144.  * removed!
  145.  * removed!
  146.  * removed!
  147.  *
  148.  * removed!
  149.  * removed!
  150.  * removed!
  151.  *
  152.  * removed!
  153.  * removed!
  154.  * removed!
  155.  *
  156.  * removed!
  157.  * removed!
  158.  * removed!
  159.  *
  160.  * removed!
  161.  * removed!
  162.  * removed!
  163.  *
  164.  * removed!
  165.  * removed!
  166.  * removed!
  167.  *
  168.  * removed!
  169.  * removed!
  170.  * removed!
  171.  *
  172.  * removed!
  173.  * removed!
  174.  * removed!
  175.  *
  176.  * removed!
  177.  * removed!
  178.  * removed!
  179.  *
  180.  * removed!
  181.  * removed!
  182.  * removed!
  183.  *
  184.  * removed!
  185.  * removed!
  186.  * removed!
  187.  *
  188.  * removed!
  189.  * removed!
  190.  * removed!
  191.  *
  192.  * removed!
  193.  * removed!
  194.  * removed!
  195.  *
  196.  * removed!
  197.  * removed!
  198.  * removed!
  199.  *
  200.  * removed!
  201.  * removed!
  202.  * removed!
  203.  *
  204.  * removed!
  205.  * removed!
  206.  * removed!
  207.  *
  208.  * removed!
  209.  * removed!
  210.  * removed!
  211.  *
  212.  * removed!
  213.  * removed!
  214.  * removed!
  215.  *
  216.  * removed!
  217.  * removed!
  218.  * removed!
  219.  *
  220.  * removed!
  221.  * removed!
  222.  * removed!
  223.  *
  224.  * removed!
  225.  * removed!
  226.  * removed!
  227.  * removed!
  228.  *
  229.  * removed!
  230.  * removed!
  231.  * removed!
  232.  *
  233.  * removed!
  234.  * removed!
  235.  * removed!
  236.  *
  237.  * removed!
  238.  * removed!
  239.  * removed!
  240.  *
  241.  * removed!
  242.  * removed!
  243.  * removed!
  244.  *
  245.  * removed!
  246.  * removed!
  247.  * removed!
  248.  *
  249.  * removed!
  250.  * removed!
  251.  * removed!
  252.  *
  253.  * removed!
  254.  * removed!
  255.  * removed!
  256.  *
  257.  * removed!
  258.  * removed!
  259.  * removed!
  260.  * removed!
  261.  *
  262.  * removed!
  263.  * removed!
  264.  * removed!
  265.  *
  266.  * removed!
  267.  * removed!
  268.  * removed!
  269.  *
  270.  * removed!
  271.  * removed!
  272.  * removed!
  273.  *
  274.  * removed!
  275.  * removed!
  276.  * removed!
  277.  *
  278.  * removed!
  279.  * removed!
  280.  * removed!
  281.  *
  282.  * removed!
  283.  * removed!
  284.  * removed!
  285.  *
  286.  * removed!
  287.  * removed!
  288.  * removed!
  289.  *
  290.  * removed!
  291.  * removed!
  292.  * removed!
  293.  *
  294.  * removed!
  295.  * removed!
  296.  * removed!
  297.  *
  298.  * removed!
  299.  * removed!
  300.  * removed!
  301.  *
  302.  * removed!
  303.  * removed!
  304.  * removed!
  305.  *
  306.  * removed!
  307.  * removed!
  308.  * removed!
  309.  *
  310.  * removed!
  311.  * removed!
  312.  * removed!
  313.  *
  314.  * removed!
  315.  * removed!
  316.  * removed!
  317.  *
  318.  * removed!
  319.  * removed!
  320.  * removed!
  321.  *
  322.  * removed!
  323.  * removed!
  324.  * removed!
  325.  *
  326.  * removed!
  327.  * removed!
  328.  * removed!
  329.  *
  330.  * removed!
  331.  * removed!
  332.  * removed!
  333.  *
  334.  * removed!
  335.  * removed!
  336.  * removed!
  337.  *
  338.  * removed!
  339.  * removed!
  340.  * removed!
  341.  *
  342.  * removed!
  343.  * removed!
  344.  * removed!
  345.  *
  346.  * removed!
  347.  * removed!
  348.  * removed!
  349.  *
  350.  * removed!
  351.  * removed!
  352.  * removed!
  353.  *
  354.  * removed!
  355.  * removed!
  356.  * removed!
  357.  *
  358.  * removed!
  359.  * removed!
  360.  * removed!
  361.  *
  362.  * removed!
  363.  * removed!
  364.  * removed!
  365.  *
  366.  * removed!
  367.  * removed!
  368.  * removed!
  369.  *
  370.  * removed!
  371.  * removed!
  372.  * removed!
  373.  *
  374.  *------------------------------------------------------------------------------
  375.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  376.  *============================================================================
  377.  ****************************************************************************/
  378. /**
  379.  * Copyright Notice
  380.  * ?2002 - 2003, Pixtel Communications, Inc., 1489 43rd Ave. W.,
  381.  * Vancouver, B.C. V6M 4K8 Canada. All Rights Reserved.
  382.  *  (It is illegal to remove this copyright notice from this software or any
  383.  *  portion of it)
  384.  */
  385. /**************************************************************
  387.    FILENAME : AlarmFramework.c
  389.    PURPOSE     : Alarm Application
  391.    REMARKS     : nil
  393.    AUTHOR      : Neeraj Sharma
  395.    DATE     : Jun 16,03
  397. **************************************************************/
  398. #ifndef _MMI_ALARMFRAMEWORK_C
  399. #define _MMI_ALARMFRAMEWORK_C
  401. /*  Include: MMI header file */
  402. #include "MMI_features.h"
  404. /* to be put in include path TBDGS */
  405. #include "StdC.h"
  406. #include "l4Dr.h"
  407. #include "L4Dr1.h"
  408. #include "AlarmProt.h"
  409. #include "AlarmGProt.h"
  410. #include "DateTimeGprot.h"
  411. #include "AlarmFrameworkProt.h"
  412. #include "NVRAMEnum.h"
  413. #include "DebugInitDef.h"
  414. #include "NVRAMType.h"
  415. #include "NVRAMProt.h"
  416. #include "SubLCDHistoryGProt.h"
  417. #include "HistoryGprot.h"
  418. #include "ScheduledPowerOnOffGprot.h"
  419. #include "gpioInc.h"
  420. #include "ProfileGprots.h"
  421. #include "QueueGprot.h"
  422. #include "MMIThemes.h"
  423. #include "ProtocolEvents.h"
  424. #include "AllAppGprot.h"
  425. #include "AsyncEventsGprot.h"
  426. #include "EventsGprot.h"
  427. #include "SettingGprots.h"
  428. #include "ComposeRingToneProts.h"
  429. #include "DownloadProtos.h"
  430. #include "PowerOnChargerProt.h"
  431. // #include "PopulateResGprot.h"
  432. #include "ScheduledPowerOnOff.h"
  433. #include "ToDoListDef.h"
  434. #include "WrapperGprot.h"
  435. #include "AudioInc.h"
  436. #include "IdleAppProt.h"
  437. #include <time.h>
  438. #include "GlobalScrEnum.h"
  439. #include "mdi_datatype.h"
  440. #include "mdi_audio.h"
  441. #ifdef MMI_ON_HARDWARE_P
  442. #include "resource_audio.h"
  443. #include "lcd_sw.h"
  444. #include "lcd_sw_inc.h"
  445. #include "sublcd.h"
  446. #endif /* MMI_ON_HARDWARE_P */ 
  448. #include "JavaAgencyDef.h"
  449. /*  Include: PS header file */
  450. //... Add More PS header
  451. //#include "Gdi_include.h"
  452. #include "SimDetectionGexdcl.h"
  453. #include "SimDetectionGprot.h"
  454. #include "Bootup.h"
  455. // #include "MMITaskProt.h"
  456. #include "USBDeviceGprot.h"
  457. #include "USBDeviceDefs.h"      /* __USB_IN_NORMAL_MODE__ */
  458. #include "mmi_trc.h"
  459. #include "CallManagementGprot.h" /*IsWapCallPresent*/
  461. #if defined(__MMI_ALM_AUDIO_OPTIONS__)
  462. #include "FMRadioDef.h"
  463. #include "FMRadioProt.h"
  464. #include "FMRadioType.h"
  465. extern mmi_fmrdo_struct g_fmrdo;
  466. #endif /* defined(__MMI_ALM_AUDIO_OPTIONS__) */ 
  468. #if defined(__MMI_FM_RADIO_SCHEDULE_REC__)
  469. #include "FMScheduleRecProt.h"
  470. #endif 
  471. #ifdef __SYNCML_SUPPORT__
  472. #include "SyncMLGprot.h"
  473. #endif
  474. #include "Fs_func.h"
  475. /* 
  476.  * Typedef 
  477.  */
  479. /* 
  480.  * Define
  481.  */
  482. #define ALM_AFTER_CM_DURATUION 5000
  483. #define ALM_MAX_DELAY_ALLOWANCE  ((NUM_OF_SPOF + NUM_OF_ALM + NUM_OF_TDL) / 2 +1)       /* maximum delay of each alarm */
  484. #define ALM_TOLERANCE_TIME       10000
  485. #define ALM_POWER_OFF_TOLERANCE  (POWER_OFF_TIMER_STAGE_1 + POWER_OFF_TIMER_STAGE_2 + ALM_TOLERANCE_TIME)
  487. /* 
  488.  * Local Variable
  489.  */
  491. /* 
  492.  * Local Function
  493.  */
  495. /* 
  496.  * Global Variable
  497.  */
  498. AlarmCallback gAlmCBHandler[ALM_TYPE_TOTAL_NUM];
  499. alm_queue_node_struct gAlmQueue[ALM_NUM_OF_ALAMRS];
  500. alm_framework_context_struct g_alm_frm_cntx;
  502. #ifdef __MMI_FACTORY_MODE__
  503. extern U8 gFactoryAlarm;
  504. #endif 
  506. #ifdef MMI_ON_HARDWARE_P
  507. extern kal_uint16 *MainLCD_ShadowBuf_p;
  508. extern kal_uint16 *SubLCD_ShadowBuf_p;
  509. extern U8 gFScheckdiskflag;
  510. extern rtc_format_struct gclockData;
  511. #endif /* MMI_ON_HARDWARE_P */ 
  513. const U8 gAlmDayOfWeek[] = 
  514. {
  515.     0x01,   /* DAY_SUN */
  516.     0x02,   /* DAY_MON */
  517.     0x04,   /* DAY_TUE */
  518.     0x08,   /* DAY_WED */
  519.     0x10,   /* DAY_THU */
  520.     0x20,   /* DAY_FRI */
  521.     0x40    /* DAY_SAT */
  522. };
  524. /* 
  525.  * Global Function
  526.  */
  527. extern void QuitSystemOperation(void);
  528. extern void InitUnicodeSupport(void);
  529. extern void ResetLanguageSettingFlag(void);
  530. extern pBOOL isInCall(void);
  531. extern void MMICheckDiskDisplay(void);
  532. extern void ShutDownSystemOperation2(void);
  533. extern void PmgInitExtMelodyStruct(void);
  534. extern void InitFramework(void);
  535. extern void gdi_init(void);
  536. extern void ShutdownSystemOperation(void);
  537. extern void InitSoundEffect(void);
  538. extern void InitDownloadNVRAM(void);
  539. #ifdef __J2ME__
  540. extern void jvm_pause_dummy_screen(void);
  541. extern void jvm_resume_dummy_screen(void);
  542. #endif /* __J2ME__ */ 
  544. #ifdef MMI_ON_HARDWARE_P
  545. #ifdef __EM_MODE__
  546. extern void custom_em_pwn_cycle(kal_bool is_on);
  547. #endif 
  548. #endif /* MMI_ON_HARDWARE_P */ 
  549. extern void PhnsetReadGPIOSetting(void);
  552. /*****************************************************************************
  553.  * FUNCTION
  554.  *  InitAlarmHandler
  555.  * DESCRIPTION
  556.  *  Initialize Alarm handler
  557.  * PARAMETERS
  558.  *  void
  559.  * RETURNS
  560.  *  void
  561.  *****************************************************************************/
  562. void InitAlarmHandler(void)
  563. {
  564.     /*----------------------------------------------------------------*/
  565.     /* Local Variables                                                */
  566.     /*----------------------------------------------------------------*/
  568.     /*----------------------------------------------------------------*/
  569.     /* Code Body                                                      */
  570.     /*----------------------------------------------------------------*/
  571. #ifdef MMI_ON_HARDWARE_P
  572.     SetProtocolEventHandler(AlmExpiryHandler, MSG_ID_MMI_EQ_ALARM_IND);
  573. #endif 
  574. }
  577. /*****************************************************************************
  578.  * FUNCTION
  579.  *  InitAlarmFrameWork
  580.  * DESCRIPTION
  581.  *  Initialize global context and retrieve all kinds of alarm from NVRAM.
  582.  * PARAMETERS
  583.  *  void
  584.  * RETURNS
  585.  *  void
  586.  *****************************************************************************/
  587. void InitAlarmFrameWork(void)
  588. {
  589.     /*----------------------------------------------------------------*/
  590.     /* Local Variables                                                */
  591.     /*----------------------------------------------------------------*/
  592.     S32 i;
  594.     /*----------------------------------------------------------------*/
  595.     /* Code Body                                                      */
  596.     /*----------------------------------------------------------------*/
  597.     /* 
  598.      * init callback function
  599.      */
  600.     AlmFCBInit();
  601. #if defined(__MMI_TODOLIST__)
  602.     TDLFCBInit();
  603. #endif 
  605. #ifdef __MMI_THEMES_APPLICATION__
  606.     ThemesFCBInit();
  607. #endif 
  608.     SPOFFCBInit();
  610. #if defined(__MMI_FM_RADIO_SCHEDULE_REC__)
  611.     mmi_fmsr_int_cb_function();
  612. #endif 
  614. #ifdef __SYNCML_SUPPORT__
  615.     mmi_syncml_init_alarm();
  616. #endif
  618.     /*
  619.      * init alarm NVRAM
  620.      */
  621.     for (i = 0; i < ALM_TYPE_TOTAL_NUM; i++)
  622.     {
  623.         if (gAlmCBHandler[i].initAlarmNvramCBPtr)
  624.         {
  625.             gAlmCBHandler[i].initAlarmNvramCBPtr();
  626.         }
  627.     }
  629. #if (!defined(MMI_ON_WIN32) && defined(__MMI_ENGINEER_MODE__))
  630.     /*  init Factory RTC and Reset */
  631.     mmi_alm_set_start_index(ALM_TYPE_FACTORY, ALM_FACTORY);
  632.     gAlmCBHandler[ALM_TYPE_FACTORY].expiryTimeCBPtr = FactoryExpiryTimeCB;
  633.     gAlmCBHandler[ALM_TYPE_FACTORY].expiryHandlerCBPtr = FactoryExpiryHandler;
  634. #endif /* (!defined(MMI_ON_WIN32) && defined(__MMI_ENGINEER_MODE__)) */ 
  636.     mmi_alm_set_start_index(ALM_TYPE_PWR_RESET, ALM_PWR_RESET);
  637.     gAlmCBHandler[ALM_TYPE_PWR_RESET].expiryTimeCBPtr = ResetExpiryTimeCB;
  638.     gAlmCBHandler[ALM_TYPE_PWR_RESET].expiryHandlerCBPtr = ResetExpiryHandler;
  639.     InitAlarmHandler();
  641.     AlmInitQueue();
  643.     memset(&g_alm_frm_cntx, 0, sizeof(alm_framework_context_struct));
  644.     g_alm_frm_cntx.CurrAlmIndex = 0xff;
  645.     g_alm_frm_cntx.IsAppExecuting = MMI_FALSE;
  647.     for (i = 0; i < ALM_NUM_OF_ALAMRS && gAlmQueue[i].Index < ALM_INDEX_TOTAL; i++);
  649.     g_alm_frm_cntx.EnabledAlarms = (U8) i;
  650.     if (i && g_pwr_context.PowerOnMode != POWER_ON_ALARM)
  651.     {
  652.         AlmCheckAlarmState();
  653.     }
  655. }
  658. /*****************************************************************************
  659.  * FUNCTION
  660.  *  AlmCancelAlarmRsp
  661.  * DESCRIPTION
  662.  *  Protocol Handler for Message Alarm Del Response
  663.  *  Enabled Expiry Handler
  664.  * PARAMETERS
  665.  *  msg     [?]     
  666.  * RETURNS
  667.  *  void
  668.  *****************************************************************************/
  669. void AlmCancelAlarmRsp(void *msg)
  670. {
  671.     /*----------------------------------------------------------------*/
  672.     /* Local Variables                                                */
  673.     /*----------------------------------------------------------------*/
  675.     /*----------------------------------------------------------------*/
  676.     /* Code Body                                                      */
  677.     /*----------------------------------------------------------------*/
  678. #ifdef MMI_ON_HARDWARE_P
  679.     SetProtocolEventHandler(AlmExpiryHandler, MSG_ID_MMI_EQ_ALARM_IND);
  680. #endif 
  681. }
  684. /*****************************************************************************
  685.  * FUNCTION
  686.  *  AlmSetAlarmRSP
  687.  * DESCRIPTION
  688.  *  Protocol Handler for Message Alarm Set Response
  689.  * PARAMETERS
  690.  *  msg     [?]     
  691.  * RETURNS
  692.  *  void
  693.  *****************************************************************************/
  694. void AlmSetAlarmRSP(void *msg)
  695. {
  696. #ifdef MMI_ON_HARDWARE_P
  697.     /*----------------------------------------------------------------*/
  698.     /* Local Variables                                                */
  699.     /*----------------------------------------------------------------*/
  700.     mmi_eq_set_rtc_time_rsp_struct *alarmRes;
  702.     /*----------------------------------------------------------------*/
  703.     /* Code Body                                                      */
  704.     /*----------------------------------------------------------------*/
  705.     alarmRes = (mmi_eq_set_rtc_time_rsp_struct*) msg;
  707. #ifdef MMI_ON_HARDWARE_P
  708.     SetProtocolEventHandler(AlmExpiryHandler, MSG_ID_MMI_EQ_ALARM_IND);
  709. #endif 
  711.     if (alarmRes->result == MMI_TRUE)
  712.     {
  713.     #ifdef MMI_ON_HARDWARE_P
  714.     #ifdef __MMI_FACTORY_MODE__
  715.         if (gFactoryAlarm == 1)
  716.         {
  717.             gFactoryAlarm = 0;
  718.             if (g_alm_frm_cntx.IsATPwrOffAnimation)
  719.             {
  720.                 ShutdownSystemOperation();
  721.             }
  722.             else
  723.             {
  724.             #ifdef __MTK_TARGET__
  725.                 CloseBacklight();
  726.                 FS_ClearDiskFlag();
  727.                 custom_em_pwn_cycle(KAL_FALSE);
  728.             #else /* __MTK_TARGET__ */ 
  729.                 exit(0);
  730.             #endif /* __MTK_TARGET__ */ 
  731.             }
  732.             return;
  733.         }
  734.     #endif /* __MMI_FACTORY_MODE__ */ 
  735.     #endif /* MMI_ON_HARDWARE_P */ 
  736.         if (g_alm_frm_cntx.IsWaitForPwroff /* == ALM_STATE_POWER_OFF */ )
  737.         {
  738.             g_alm_frm_cntx.IsWaitForPwroff = 0;
  739.             /* if charger connected or power on confirmation screen present */
  741.             if (g_alm_frm_cntx.IsAppExecuting == 0)
  742.             {
  743.                 AlmSendPowerOff();
  744.             }
  745.         }
  746.     }
  747. #endif /* MMI_ON_HARDWARE_P */ 
  748. }
  751. /*****************************************************************************
  752.  * FUNCTION
  753.  *  PendingAlarmReminder
  754.  * DESCRIPTION
  755.  *  Execute pending after a certain period after call or first time entry idle screen.
  756.  * PARAMETERS
  757.  *  void
  758.  * RETURNS
  759.  *  void
  760.  *****************************************************************************/
  761. void PendingAlarmReminder(void)
  762. {
  763.     /*----------------------------------------------------------------*/
  764.     /* Local Variables                                                */
  765.     /*----------------------------------------------------------------*/
  767.     /*----------------------------------------------------------------*/
  768.     /* Code Body                                                      */
  769.     /*----------------------------------------------------------------*/
  770.     if (g_alm_frm_cntx.IsPendingAlm && g_alm_frm_cntx.IsAlmTonePlaying == FALSE)
  771.     {
  772.         StartTimer(ALARM_TIMER_WAIT_FOR_CALL, ALM_AFTER_CM_DURATUION, AlmHandlePendingTimeout);
  773.     }
  774.     else if (g_alm_frm_cntx.IsAlmTonePlaying)
  775.     {
  776.         StartTimer(ALARM_ALERT_NOTIFYDURATION_TIMER, ALM_EXPIRE_DURATION, AlmHandleAlarmTimeout);
  777.     }
  778. }
  781. /*****************************************************************************
  782.  * FUNCTION
  783.  *  PendingAlarmInPwronPeriod
  784.  * DESCRIPTION
  785.  *  Execute pending alarm in security check screen.
  786.  * PARAMETERS
  787.  *  void
  788.  * RETURNS
  789.  *  void
  790.  *****************************************************************************/
  791. void PendingAlarmInPwronPeriod(void)
  792. {
  793.     /*----------------------------------------------------------------*/
  794.     /* Local Variables                                                */
  795.     /*----------------------------------------------------------------*/
  797.     /*----------------------------------------------------------------*/
  798.     /* Code Body                                                      */
  799.     /*----------------------------------------------------------------*/
  800.     if (g_alm_frm_cntx.IsPendingAlm)
  801.     {
  802.         AlmHandlePendingTimeout();
  803.     }
  804. }
  807. /*****************************************************************************
  808.  * FUNCTION
  809.  *  AlmActualTime
  810.  * DESCRIPTION
  811.  *  Calculates the time when alarm will expire as per the frequency and weekdays.
  812.  * PARAMETERS
  813.  *  t               [IN]        Time of the alarm.
  814.  *  frequency       [IN]        Repeat of the alarm.
  815.  *  weekDays        [IN]        
  816.  *  is_tdl(?)       [IN]        If the alarm is to do list.
  817.  *  weekdays(?)     [IN]        Weekdays of the alarm. Each bit is set for every day. Bit 0 for sunday and so on
  818.  * RETURNS
  819.  *  Next expired time of the alarm.
  820.  *****************************************************************************/
  821. MYTIME AlmActualTime(MYTIME t, FREQ_ALARM frequency, U8 weekDays)
  822. {
  823.     /*----------------------------------------------------------------*/
  824.     /* Local Variables                                                */
  825.     /*----------------------------------------------------------------*/
  826.     MYTIME currTime, incTime;
  827.     TIME_EQUALITY diffStatus, diffStatus2;
  828.     U8 hasDate, j;
  830.     /*----------------------------------------------------------------*/
  831.     /* Code Body                                                      */
  832.     /*----------------------------------------------------------------*/
  833.     DTGetRTCTime(&currTime);
  834.     memset(&incTime, 0, sizeof(incTime));
  835.     hasDate = (t.nMonth != 0 && t.nDay != 0);
  837.     /* If frequency is days, alarm time should be calculated even it is greater than current time */
  838.     if (CompareTime(t, currTime, NULL) != TIME_GREATER || frequency == ALM_FREQ_DAYS) 
  839.     {
  840.         switch (frequency)
  841.         {
  842.             case ALM_FREQ_ONCE:
  843.             case ALM_FREQ_HOURLY:
  844.             case ALM_FREQ_EVERYDAY:            
  845.             case ALM_FREQ_WEEKLY:
  846.                 t.nYear = currTime.nYear;
  847.                 t.nMonth = currTime.nMonth;
  848.                 t.nDay = currTime.nDay;
  849.                 if (frequency == ALM_FREQ_ONCE || frequency == ALM_FREQ_EVERYDAY || frequency == ALM_FREQ_HOURLY)
  850.                 {
  851.                     if (frequency == ALM_FREQ_HOURLY)
  852.                     {
  853.                         t.nHour = currTime.nHour;
  854.                         incTime.nHour = 1;
  855.                     }
  856.                     else
  857.                     {
  858.                         incTime.nDay = 1;
  859.                     }
  860.                     diffStatus = CompareTime(t, currTime, NULL);
  861.                     if (diffStatus == TIME_LESS || diffStatus == TIME_EQUAL)
  862.                     {
  863.                         IncrementTime(t, incTime, &t);
  864.                     }
  865.                 }                
  866.                 else    /* frequency == ALM_FREQ_WEEKLY */
  867.                 {
  868.                     if (t.DayIndex == currTime.DayIndex)
  869.                     {
  870.                         diffStatus = CompareTime(t, currTime, NULL);
  871.                         if (diffStatus == TIME_LESS || diffStatus == TIME_EQUAL)
  872.                         {
  873.                             incTime.nDay = 7;
  874.                              IncrementTime(t, incTime, &t);
  875.                         }
  876.                     }
  877.                     else
  878.                     {
  879.                         incTime.nDay = (7 + t.DayIndex - currTime.DayIndex) % 7;
  880.                         IncrementTime(t, incTime, &t);
  881.                     }
  882.                 }
  883.                 break;
  884.                 
  885. case ALM_FREQ_DAYS:
  886.              diffStatus = CompareTime(t, currTime, NULL);
  887.              /* alarm time is larger than current time, calculate next alarm since alarm time. */
  888.              if (diffStatus == TIME_GREATER)           
  889.              {     
  890.              memcpy (&currTime, &t, sizeof(MYTIME));
  891.              }                   
  892.                 for (j = 0; j < 7; j++)
  893.                 {
  894.                     if (gAlmDayOfWeek[(currTime.DayIndex + j) % 7] & weekDays)
  895.                     {
  896.                         break;
  897.                     }
  898.                 }
  899.                 if (!j) /* if it's the same day */
  900.                 {
  901. /* compare HH:MM:SS */
  902. t.nYear = currTime.nYear;
  903. t.nMonth = currTime.nMonth;
  904. t.nDay = currTime.nDay;
  905. diffStatus2 = CompareTime(t, currTime, NULL);
  906. /* alarm time is less than current time and the HH/MM/SS is less than current time*/
  907.                     if (diffStatus != TIME_GREATER && diffStatus2 != TIME_GREATER)//(diffStatus2 == TIME_LESS || diffStatus2 == TIME_EQUAL) )
  908.                     {
  909.                         /* Find Next Day When then the alarm is scheduled */
  910.                         for (j = 1; j < 7; j++)
  911.                         {
  912.                             if (gAlmDayOfWeek[(currTime.DayIndex + j) % 7] & weekDays)
  913.                             {
  914.                                 break;
  915.                              }
  916.                         }
  917.                     }
  918.                     else
  919.                     {
  920.                         break;
  921.                     }
  922.                 }
  923. if (diffStatus == TIME_LESS || diffStatus == TIME_EQUAL)
  924. {
  925. currTime.nHour = t.nHour;
  926. currTime.nMin= t.nMin;
  927. currTime.nSec= t.nSec;
  928. }
  929.                 incTime.nDay = j;
  930.                 IncrementTime(currTime, incTime, &t);
  931.                 break;
  932.             default:
  933.                 break;
  934.         }
  935.     }
  937.     /* for yearly, monthly, seasonally, whether alarm time is before or afeter current time, next expiry time should be re-calculated. */
  938.     switch (frequency)
  939.     {
  940.         case ALM_FREQ_MONTHLY:
  941.                 if (!hasDate)
  942.                 {
  943.                     t.nDay = 1;
  944. t.nYear = currTime.nYear;
  945. t.nMonth = currTime.nMonth;
  946.                 }
  947. else if(CompareTime(t, currTime, NULL) != TIME_GREATER)
  948. {
  949. t.nYear = currTime.nYear;
  950. t.nMonth = currTime.nMonth;
  951. }
  953.             diffStatus = CompareTime(t, currTime, NULL);
  954.             if (diffStatus == TIME_LESS || diffStatus == TIME_EQUAL)    /* || (LastDayOfMonth(t.nMonth, t.nYear) < t.nDay)) */
  955.             {
  956.                 if (currTime.nMonth == 12)
  957.                 {
  958. t.nMonth = 1;
  959.                     t.nYear++;
  960.                 }
  961.                 else
  962.                 {
  963. t.nMonth++;
  964.                 }
  965.             }
  966. j = t.nMonth;                
  968.             for (; j <= 12; j++)
  969.             {
  970.                 if (LastDayOfMonth(t.nMonth, t.nYear) >= t.nDay)
  971.                 {
  972.                     break;
  973.                 }
  974.             }
  975.             break;
  977.         case ALM_FREQ_YEARLY:
  978.             if (!hasDate)
  979.             {
  980.                 t.nYear = currTime.nYear;
  981.                 t.nMonth = 1;
  982.                 t.nDay = 1;
  983.                 }
  984. else if(CompareTime(t, currTime, NULL) != TIME_GREATER)
  985. {
  986. t.nYear = currTime.nYear;
  987.             }
  989.             diffStatus = CompareTime(t, currTime, NULL);
  990.             if (diffStatus == TIME_LESS || diffStatus == TIME_EQUAL)
  991.             {
  992. if (t.nMonth == 2 && t.nDay == 29)
  993. {
  994. incTime.nYear = 4 - ((t.nYear) % 4);
  995. IncrementTime(t, incTime, &t);
  996. }
  997. else
  998. {
  999. t.nYear++;
  1000. }
  1001.             }
  1002.             
  1003.             break;
  1005.         case ALM_FREQ_SEASONALLY:
  1006.             t.nYear = currTime.nYear;
  1007.             if (!hasDate)
  1008.             {
  1009.                 t.nDay = 1;
  1010.             }
  1011.             switch (currTime.nMonth)
  1012.             {
  1013.                 case 1:
  1014.                 case 2:
  1015.                 case 3:
  1016.                     t.nMonth = 4;
  1017.                     break;
  1018.                 case 4:
  1019.                 case 5:
  1020.                 case 6:
  1021.                     t.nMonth = 7;
  1022.                     break;
  1023.                 case 7:
  1024.                 case 8:
  1025.                 case 9:
  1026.                     t.nMonth = 10;
  1027.                     break;
  1028.                 default:    /* case 10: case 11: case 12: */
  1029.                     t.nMonth = 1;
  1030.                     t.nYear = (currTime.nYear + 1);
  1031.                     break;
  1032.             }
  1033.             break;
  1034.         default:
  1035.             break;
  1036.     }
  1038.     return t;
  1039. }
  1042. /*****************************************************************************
  1043.  * FUNCTION
  1044.  *  AlmsStopAlarmTone
  1045.  * DESCRIPTION
  1046.  *  Stops Any Alarm Tone that may be playing
  1047.  * PARAMETERS
  1048.  *  void
  1049.  * RETURNS
  1050.  *  void
  1051.  *****************************************************************************/
  1052. void AlmsStopAlarmTone(void)
  1053. {
  1054.     /*----------------------------------------------------------------*/
  1055.     /* Local Variables                                                */
  1056.     /*----------------------------------------------------------------*/
  1057.     
  1058. #if defined (__MMI_ALM_ALERT_TYPE__) || defined (__MMI_PROFILE_ALERT_TYPE_DOMINANT__)
  1059.         U8 alert_type;
  1060. #endif 
  1061.         U8 alarm_index = g_alm_frm_cntx.CurrAlmIndex - ALM_ALM_START;
  1062.     
  1063.     /*----------------------------------------------------------------*/
  1064.     /* Code Body                                                      */
  1065.     /*----------------------------------------------------------------*/
  1066.     if (g_alm_frm_cntx.IsAlmTonePlaying)
  1067.     {
  1068.         /* stopRequestedTone(ALARM_TONE); */
  1069. #if defined (__MMI_ALM_ALERT_TYPE__)
  1070.         alert_type = g_alm_cntx.AlmList[alarm_index].AlertType;
  1071.         switch (alert_type)
  1072.         {
  1073.             case ALM_ALERT_VIBRATION_AND_RING:
  1074.                 VibratorOff();
  1075.                 mdi_audio_stop_all();
  1076.                 break;
  1077.             case ALM_ALERT_RING:
  1078.                 mdi_audio_stop_all();
  1079.                 break;
  1080.             case ALM_ALERT_VIBRATION:
  1081.                 VibratorOff();
  1082.                 break;
  1083.             default:
  1084.                 break;
  1085.         }
  1086. #else
  1087.         mdi_audio_stop_all();;
  1088.         VibratorOff();
  1089. #endif
  1090.         g_alm_frm_cntx.IsAlmTonePlaying = FALSE;
  1091.     }
  1092. }
  1095. /*****************************************************************************
  1096.  * FUNCTION
  1097.  *  AlmPlayAlarmTone
  1098.  * DESCRIPTION
  1099.  *  Play alarm tone if it's not playing.
  1100.  * PARAMETERS
  1101.  *  void
  1102.  * RETURNS
  1103.  *  void
  1104.  *****************************************************************************/
  1105. void AlmPlayAlarmTone(void)
  1106. {
  1107.     /*----------------------------------------------------------------*/
  1108.     /* Local Variables                                                */
  1109.     /*----------------------------------------------------------------*/
  1110. #if defined (__MMI_ALM_ALERT_TYPE__) || defined (__MMI_PROFILE_ALERT_TYPE_DOMINANT__)
  1111.     U8 alert_type;
  1112. #endif 
  1113.     U8 alarm_index = g_alm_frm_cntx.CurrAlmIndex - ALM_ALM_START;
  1115.     /*----------------------------------------------------------------*/
  1116.     /* Code Body                                                      */
  1117.     /*----------------------------------------------------------------*/
  1118.     if (g_alm_frm_cntx.IsAlmTonePlaying == FALSE)
  1119.     {
  1120.         g_alm_frm_cntx.IsAlmTonePlaying = TRUE;
  1121.     #if defined (__MMI_ALM_ALERT_TYPE__)
  1122.         alert_type = g_alm_cntx.AlmList[alarm_index].AlertType;
  1123.         switch (alert_type)
  1124.         {
  1125.             case ALM_ALERT_VIBRATION_AND_RING:
  1126.                 VibratorOn();
  1127.                 break;
  1128.             case ALM_ALERT_VIBRATION:
  1129.                 VibratorOn();
  1130.                 return;
  1131.                 break;
  1132.             default:
  1133.                 break;
  1134.         }
  1135.     #elif defined(__MMI_PROFILE_ALERT_TYPE_DOMINANT__)
  1136.         alert_type = GetMtCallAlertTypeEnum();
  1137.         VibratorOn();
  1138.         if (alert_type != MMI_VIBRATION_ONLY && alert_type != MMI_SILENT)
  1139.     #endif 
  1140.         {
  1141.             /* Added support for Alarm Audio Options i.e. FM Radio as alarm tone. */
  1142.         #ifdef __MMI_ALM_AUDIO_OPTIONS__
  1143.             if (g_alm_frm_cntx.CurrAlmIndex >= ALM_ALM_START && g_alm_frm_cntx.CurrAlmIndex < ALM_SPOF_START)
  1144.             {
  1145.                 if (g_alm_cntx.AlmList[alarm_index].AudioOption == ALM_AUDIO_OPTIONS_TONE)
  1146.                 {
  1147.                     playRequestedTone(ALARM_TONE);
  1148.                 }
  1149.                 else
  1150.                 {
  1151.                     mmi_alm_aud_fmrdo_play_alarm(alarm_index, GetRingVolumeLevel());
  1152.                 }
  1153.             }
  1154.             else
  1155.         #endif /* __MMI_ALM_AUDIO_OPTIONS__ */ 
  1156.             {
  1157.                 playRequestedTone(ALARM_TONE);
  1158.             }
  1159.         }
  1160.     }
  1161. }
  1164. /*****************************************************************************
  1165.  * FUNCTION
  1166.  *  AlmInitLCDModule
  1167.  * DESCRIPTION
  1168.  *  Initialize main and sub lcd
  1169.  * PARAMETERS
  1170.  *  void
  1171.  * RETURNS
  1172.  *  void
  1173.  *****************************************************************************/
  1174. void AlmInitLCDModule(void)
  1175. {
  1176.     /*----------------------------------------------------------------*/
  1177.     /* Local Variables                                                */
  1178.     /*----------------------------------------------------------------*/
  1180.     /*----------------------------------------------------------------*/
  1181.     /* Code Body                                                      */
  1182.     /*----------------------------------------------------------------*/
  1183.     gdi_init();
  1184. }
  1187. /*****************************************************************************
  1188.  * FUNCTION
  1189.  *  AlmInitRTCPwron
  1190.  * DESCRIPTION
  1191.  *  Initialize all required data and modules for RTC power on.
  1192.  * PARAMETERS
  1193.  *  void
  1194.  * RETURNS
  1195.  *  void
  1196.  *****************************************************************************/
  1197. void AlmInitRTCPwron(void)
  1198. {
  1199.     /*----------------------------------------------------------------*/
  1200.     /* Local Variables                                                */
  1201.     /*----------------------------------------------------------------*/
  1203.     /*----------------------------------------------------------------*/
  1204.     /* Code Body                                                      */
  1205.     /*----------------------------------------------------------------*/
  1206.     InitUnicodeSupport();
  1207.     PhnsetReadGPIOSetting();
  1209.     mdi_audio_init();
  1211.     InitFramework();            /* Initialize framework */
  1212.     InitHardwareEvents();
  1213.     setup_UI_wrappers();
  1214.     PopulateResData();
  1215.     PowerAndEndKeyHandler();    /* deepali */
  1216.     initialize_UI_demo();
  1217.     InitProfileApp();
  1218.     InitMMI_App();
  1219.     InitChargerPwrOn();
  1221.     InitDownloadNVRAM();
  1222.     initnvramprofapp();
  1223.     InitSettingNVRAM();
  1224. #if defined(__MMI_RING_COMPOSER__) && defined(__MMI_IMELODY_SUPPORT__)
  1225.     InitRingToneComposer();
  1226. #endif 
  1228. #ifdef __MMI_USB_SUPPORT__
  1229.     InitMMIUsbContext();
  1230. #endif 
  1232. #ifdef __MMI_PROFILE_EXTMELODY_SUPPORT__
  1233.     PmgInitExtMelodyStruct();
  1234. #endif 
  1236.     mdi_audio_init_event_hdlrs();
  1237.     InitAlarmFrameWork();
  1238. #ifdef __MMI_THEMES_APPLICATION__
  1239.     InitThemes();
  1240. #endif 
  1242.     InitSoundEffect();
  1244.     g_alm_frm_cntx.IsPwronAlarm = TRUE;
  1246.     AlmExecPwrOffAlarm();
  1247. }
  1250. /*****************************************************************************
  1251.  * FUNCTION
  1252.  *  AlmSendPwronReq
  1253.  * DESCRIPTION
  1254.  *  Send power on request to L4. This function is used for RTC power on.
  1255.  * PARAMETERS
  1256.  *  void
  1257.  * RETURNS
  1258.  *  void
  1259.  *****************************************************************************/
  1260. void AlmSendPwronReq()
  1261. {
  1262. #ifdef MMI_ON_HARDWARE_P
  1263.     /*----------------------------------------------------------------*/
  1264.     /* Local Variables                                                */
  1265.     /*----------------------------------------------------------------*/
  1266.     MYQUEUE Message;
  1267.     mmi_eq_power_on_req_struct *myMsgPtr;
  1269.     /*----------------------------------------------------------------*/
  1270.     /* Code Body                                                      */
  1271.     /*----------------------------------------------------------------*/
  1272.     myMsgPtr = (mmi_eq_power_on_req_struct*) OslConstructDataPtr(sizeof(mmi_eq_power_on_req_struct));
  1273.     myMsgPtr->fun = 2;
  1274.     myMsgPtr->rst = 0;
  1275.     Message.oslSrcId = MOD_MMI;
  1276.     Message.oslDestId = MOD_L4C;
  1277.     Message.oslMsgId = PRT_EQ_POWER_ON_REQ;
  1278.     Message.oslDataPtr = (oslParaType*) myMsgPtr;
  1279.     Message.oslPeerBuffPtr = NULL;
  1280.     OslMsgSendExtQueue(&Message);
  1281. #endif /* MMI_ON_HARDWARE_P */ 
  1282. }
  1285. /*****************************************************************************
  1286.  * FUNCTION
  1287.  *  AlmSetAlarm
  1288.  * DESCRIPTION
  1289.  *  To insert alarm into queue and register the nearest alarm to RTC.
  1290.  *  Update alarm profile of L4C if it's normal alarm.
  1291.  * PARAMETERS
  1292.  *  index       [IN]        Index of alarm
  1293.  * RETURNS
  1294.  *  void
  1295.  *****************************************************************************/
  1296. void AlmSetAlarm(U8 index)
  1297. {
  1298. #ifdef MMI_ON_HARDWARE_P
  1299.     /*----------------------------------------------------------------*/
  1300.     /* Local Variables                                                */
  1301.     /*----------------------------------------------------------------*/
  1303.     /*----------------------------------------------------------------*/
  1304.     /* Code Body                                                      */
  1305.     /*----------------------------------------------------------------*/
  1306.     AlmInsertIntoQueue(index, TRUE);
  1307.     AlmStartAlarmOnHW(gAlmQueue[0].Time);
  1308. #endif /* MMI_ON_HARDWARE_P */ 
  1309. }
  1312. /*****************************************************************************
  1313.  * FUNCTION
  1314.  *  AlmCancelAlarm
  1315.  * DESCRIPTION
  1316.  *  To remove alarm from queue and register the nearest alarm to RTC.
  1317.  *  Update alarm profile of L4C if it's normal alarm.
  1318.  * PARAMETERS
  1319.  *  index       [IN]        Index of alarm
  1320.  * RETURNS
  1321.  *  void
  1322.  *****************************************************************************/
  1323. void AlmCancelAlarm(U8 index)
  1324. {
  1325. #ifdef MMI_ON_HARDWARE_P
  1326.     /*----------------------------------------------------------------*/
  1327.     /* Local Variables                                                */
  1328.     /*----------------------------------------------------------------*/
  1330.     /*----------------------------------------------------------------*/
  1331.     /* Code Body                                                      */
  1332.     /*----------------------------------------------------------------*/
  1333.     AlmRemoveFromQueue(index, TRUE);
  1335.     /* re-schedule alarm of RTC, shall be implemented in another function */
  1336.     if (g_alm_frm_cntx.EnabledAlarms == 0)
  1337.     {
  1338.         AlmStopAlarmOnHW();
  1339.     }
  1340.     else
  1341.     {
  1342.         AlmStartAlarmOnHW(gAlmQueue[0].Time);
  1343.     }
  1345.     /* update L4 state */
  1346.     //      if(AlmGetType(index) == ALM_TYPE_ALARM)
  1347.     //              AlmDelRTCInfoForAT(index - ALM_ALM_START);
  1349. #endif /* MMI_ON_HARDWARE_P */ 
  1350. }
  1352. /*****************************************************************************
  1353.  * FUNCTION
  1354.  *  AlmCancelAlarm
  1355.  * DESCRIPTION
  1356.  *  To remove alarm from queue and register the nearest alarm to RTC.
  1357.  *  Update alarm profile of L4C if it's normal alarm.
  1358.  * PARAMETERS
  1359.  *  index       [IN]        Index of alarm
  1360.  * RETURNS
  1361.  *  void
  1362.  *****************************************************************************/
  1363. void AlmCancelMulltiAlarm(U8* index, U8 amount)
  1364. {
  1365. #ifdef MMI_ON_HARDWARE_P
  1366.     /*----------------------------------------------------------------*/
  1367.     /* Local Variables                                                */
  1368.     /*----------------------------------------------------------------*/
  1369.     U8 i = 0;
  1371.     /*----------------------------------------------------------------*/
  1372.     /* Code Body                                                      */
  1373.     /*----------------------------------------------------------------*/
  1374.     for (; i < amount; i++)
  1375.     {
  1376.         AlmRemoveFromQueue(index[i], FALSE);
  1377.     }
  1379.     AlmWriteQueueToNvram();
  1381.     /* re-schedule alarm of RTC, shall be implemented in another function */
  1382.     if (g_alm_frm_cntx.EnabledAlarms == 0)
  1383.     {
  1384.         AlmStopAlarmOnHW();
  1385.     }
  1386.     else
  1387.     {
  1388.         AlmStartAlarmOnHW(gAlmQueue[0].Time);
  1389.     }
  1392. #endif /* MMI_ON_HARDWARE_P */ 
  1393. }
  1395. /*****************************************************************************
  1396.  * FUNCTION
  1397.  *  AlmGetAlarmTime
  1398.  * DESCRIPTION
  1399.  *  Get the time of specific queue node.
  1400.  * PARAMETERS
  1401.  *  index       [IN]        Index of alarm
  1402.  * RETURNS
  1403.  *  Expired time of the alarm.
  1404.  *****************************************************************************/
  1405. MYTIME AlmGetAlarmTime(U8 index)
  1406. {
  1407.     /*----------------------------------------------------------------*/
  1408.     /* Local Variables                                                */
  1409.     /*----------------------------------------------------------------*/
  1410.     U8 AlmType;
  1411.     U8 AlmIndex;
  1412.     MYTIME alarmTime, preReminder, currTime, incTime;
  1413.     U8 Freq = 0;
  1414.     U8 WeekDays = 0;
  1416.     /*----------------------------------------------------------------*/
  1417.     /* Code Body                                                      */
  1418.     /*----------------------------------------------------------------*/
  1419.     memset(&alarmTime, 0, sizeof(MYTIME));
  1420.     memset(&preReminder, 0, sizeof(MYTIME));
  1421.     memset(&incTime, 0, sizeof(MYTIME));
  1422.     GetDateTime(&currTime);
  1423.     AlmType = AlmGetType(index);
  1424.     AlmIndex = index - gAlmCBHandler[AlmType].alarmStartIndex;
  1425.     if (gAlmCBHandler[AlmType].expiryTimeCBPtr)
  1426.     {
  1427.         gAlmCBHandler[AlmType].expiryTimeCBPtr(AlmIndex, &alarmTime, &Freq, &WeekDays, &preReminder);
  1428.     }
  1429.     alarmTime = AlmActualTime(alarmTime, (FREQ_ALARM) Freq, WeekDays);
  1430.     memcpy(&incTime, &preReminder, sizeof(MYTIME));
  1431.     DecrementTime(alarmTime, incTime, &alarmTime);
  1433.     /* check for preminder */
  1434.     if (CompareTime(alarmTime, currTime, NULL) != TIME_GREATER)
  1435.     {
  1436.         /* get original alarm time */
  1437.         memcpy(&incTime, &preReminder, sizeof(MYTIME));
  1438.         IncrementTime(alarmTime, incTime, &alarmTime);
  1440.         memset(&incTime, 0, sizeof(MYTIME));
  1441.         switch (Freq)
  1442.         {
  1443.             case ALM_FREQ_YEARLY:
  1444.                 incTime.nYear = 1;
  1445.                 break;
  1446.             case ALM_FREQ_MONTHLY:
  1447.                 incTime.nMonth = 1;
  1448.                 break;
  1449.             default:
  1450.                 incTime.nDay = 1;
  1451.                 break;
  1452.         }
  1453.         IncrementTime(alarmTime, incTime, &alarmTime);
  1454.         alarmTime = AlmActualTime(alarmTime, (FREQ_ALARM) Freq, WeekDays);
  1456.         DecrementTime(alarmTime, preReminder, &alarmTime);
  1457.     }
  1459.     return alarmTime;
  1460. }
  1463. /*****************************************************************************
  1464.  * FUNCTION
  1465.  *  AlmInsertIntoQueue
  1466.  * DESCRIPTION
  1467.  *  Insert an alarm node to the queue.
  1468.  * PARAMETERS
  1469.  *  index           [IN]        Index of alarm
  1470.  *  saveflag        [IN]        Flag to determine save directly to NVRAM or not
  1471.  * RETURNS
  1472.  *  The position of alarm in queue.
  1473.  *****************************************************************************/
  1474. U8 AlmInsertIntoQueue(U8 index, U8 saveflag)
  1475. {
  1476.     /*----------------------------------------------------------------*/
  1477.     /* Local Variables                                                */
  1478.     /*----------------------------------------------------------------*/
  1479.     S32 i, j;
  1480.     TIME_EQUALITY equality;
  1481.     MYTIME alarmTime;
  1483.     /*----------------------------------------------------------------*/
  1484.     /* Code Body                                                      */
  1485.     /*----------------------------------------------------------------*/
  1486.     if (index >= ALM_INDEX_TOTAL)   /* exceeds boundary */
  1487.     {
  1488.         return 0;
  1489.     }
  1491.     AlmRemoveFromQueue(index, FALSE);   /* node is in queue, remove it first */
  1493.     alarmTime = AlmGetAlarmTime(index);
  1495.     /* Check expiry time */
  1496.     if (!mmi_dt_is_valid(&alarmTime))
  1497.     {
  1498. AlmWriteQueueToNvram();
  1499.         return 0;
  1500.     }
  1502.     /* insert into proper position */
  1503.     for (i = 0; i < g_alm_frm_cntx.EnabledAlarms; i++)
  1504.     {
  1505.         equality = CompareTime(alarmTime, gAlmQueue[i].Time, NULL);
  1506.         if ((equality == TIME_LESS) || (equality == TIME_EQUAL && index < gAlmQueue[i].Index))  /* insert node here */
  1507.         {
  1508.             /* shift all nodes right */
  1509.             for (j = g_alm_frm_cntx.EnabledAlarms - 1; j >= i; j--)
  1510.             {
  1511.                 memcpy(&gAlmQueue[j + 1], &gAlmQueue[j], sizeof(alm_queue_node_struct));
  1512.             }
  1513.             break;
  1514.         }
  1515.     }
  1517.     gAlmQueue[i].Index = index;
  1518.     gAlmQueue[i].Time = alarmTime;
  1519.     gAlmQueue[i].IsExpired = 0;
  1521.     g_alm_frm_cntx.EnabledAlarms++;
  1523.     /* write alarm queue to NVRAM */
  1524.     if (saveflag)
  1525.     {
  1526.         AlmWriteQueueToNvram();
  1527.     }
  1529.     return (U8) i;
  1531. }
  1534. /*****************************************************************************
  1535.  * FUNCTION
  1536.  *  AlmRemoveFromQueue
  1537.  * DESCRIPTION
  1538.  *  Remove an alarm node from the queue.
  1539.  * PARAMETERS
  1540.  *  index           [IN]        Index of alarm
  1541.  *  saveflag        [IN]        Flag to determine save directly to NVRAM or not
  1542.  * RETURNS
  1543.  *  Number of enabled alarms.
  1544.  *****************************************************************************/
  1545. U8 AlmRemoveFromQueue(U8 index, U8 saveflag)
  1546. {
  1547.     /*----------------------------------------------------------------*/
  1548.     /* Local Variables                                                */
  1549.     /*----------------------------------------------------------------*/
  1550.     S32 i;
  1552.     /*----------------------------------------------------------------*/
  1553.     /* Code Body                                                      */
  1554.     /*----------------------------------------------------------------*/
  1555.     if (gAlmQueue[0].Index > ALM_INDEX_TOTAL)   /* queue is empty */
  1556.     {
  1557.         return 0;
  1558.     }
  1560.     for (i = 0; i < ALM_NUM_OF_ALAMRS; i++)
  1561.         if (gAlmQueue[i].Index == index)
  1562.         {
  1563.             break;
  1564.         }
  1566.     if (i >= ALM_NUM_OF_ALAMRS) /* alarm node not found */
  1567.     {
  1568.         return 0;
  1569.     }
  1571.     /* remove from queue */
  1572.     memcpy(&gAlmQueue[i], &gAlmQueue[i + 1], sizeof(alm_queue_node_struct) * (ALM_NUM_OF_ALAMRS - i - 1));
  1574.     g_alm_frm_cntx.EnabledAlarms--;
  1576.     memset(&gAlmQueue[g_alm_frm_cntx.EnabledAlarms], 0xff, sizeof(alm_queue_node_struct));
  1578.     /* write alarm queue to NVRAM */
  1579.     if (saveflag)
  1580.     {
  1581.         AlmWriteQueueToNvram();
  1582.     }
  1584.     return g_alm_frm_cntx.EnabledAlarms;
  1585. }
  1588. /*****************************************************************************
  1589.  * FUNCTION
  1590.  *  AlmIsExpireAllowed
  1591.  * DESCRIPTION
  1592.  *  
  1593.  * PARAMETERS
  1594.  *  void
  1595.  * RETURNS
  1596.  *  
  1597.  *****************************************************************************/
  1598. U8 AlmIsExpireAllowed(void)
  1599. {
  1600.     /*----------------------------------------------------------------*/
  1601.     /* Local Variables                                                */
  1602.     /*----------------------------------------------------------------*/
  1603.     U8 state;
  1604.     pBOOL PowerOnCheck;
  1605.     U16 call_count = 0;
  1607.     /*----------------------------------------------------------------*/
  1608.     /* Code Body                                                      */
  1609.     /*----------------------------------------------------------------*/
  1610.     if (mmi_bootup_is_before_power_on() == 1)
  1611.     {
  1612.         PowerOnCheck = MMI_FALSE;   /* the case of alarm expiration + power on indication */
  1613.     }
  1614.     else if (mmi_bootup_is_in_power_on_period() == 0)
  1615.     {
  1616.         PowerOnCheck = MMI_TRUE;    /* the case of idle screen reached + alarm expiration */
  1617.     }
  1618.     else if (IsScreenPresent(SCR_OPEN_SCREEN_ID))
  1619.     {
  1620.         PowerOnCheck = MMI_TRUE;    /* the case of power on animation + MT call + IMEI + call end + alarm expiration */
  1621.     }
  1622.     else
  1623.     {
  1624.         PowerOnCheck = MMI_FALSE;   /* the case of power on animation + alarm expiration */
  1625.     }
  1627.     if (isInCall())
  1628.     {
  1629.      if (!IsWapCallPresent())
  1630.      {
  1631.      call_count = isInCall();
  1632.      }
  1633.      else if (GetTotalCallCount() == 1)
  1634.      {
  1635.      g_alm_frm_cntx.IsExpiryDisabled = MMI_FALSE;
  1636.      }    
  1637.     }
  1640.     state = ((call_count == 0) && (PowerOnCheck == MMI_TRUE) && (!g_alm_frm_cntx.IsExpiryDisabled));
  1642.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_RTC_ALARM_EXPIRY_STATE, (S32) call_count, (S32) PowerOnCheck,
  1643.                (S32) g_alm_frm_cntx.IsExpiryDisabled));
  1645.     return state;
  1646. }
  1649. /*****************************************************************************
  1650.  * FUNCTION
  1651.  *  AlmHandleAlarmTimeout
  1652.  * DESCRIPTION
  1653.  *  Timer expiry handler for normal alarm.
  1654.  *  Exit previous alarm screen.
  1655.  * PARAMETERS
  1656.  *  void
  1657.  *  index(?)        [IN]        Index of alarm
  1658.  * RETURNS
  1659.  *  void
  1660.  *****************************************************************************/
  1661. void AlmHandleAlarmTimeout(void)
  1662. {
  1663.     /*----------------------------------------------------------------*/
  1664.     /* Local Variables                                                */
  1665.     /*----------------------------------------------------------------*/
  1666.     U8 almType = 0;
  1668.     /*----------------------------------------------------------------*/
  1669.     /* Code Body                                                      */
  1670.     /*----------------------------------------------------------------*/
  1671.     StopTimer(ALARM_ALERT_NOTIFYDURATION_TIMER);
  1673.     almType = AlmGetType(g_alm_frm_cntx.CurrAlmIndex);
  1674.     if (g_alm_frm_cntx.CurrAlmIndex == ALM_FACTORY)
  1675.     {
  1676.         AlmSendPowerOff();
  1677.     }
  1678.     else if (GetActiveScreenId() == SCR_ID_SPOF_CONFIRM)
  1679.     {
  1680.         ShutdownSystemOperation();
  1681.     }
  1682.     else
  1683.     {
  1684.         if (AlmIsExpireAllowed())
  1685.         {
  1686.             g_alm_frm_cntx.IsExitByTimer = TRUE;
  1687.             AlmExitPreviousAlarm();
  1688.             g_alm_frm_cntx.IsExitByTimer = FALSE;
  1690.             if (g_alm_frm_cntx.IsPwronAlarm)
  1691.             {
  1692.                 AlmExecPwrOffAlarm();
  1693.             }
  1694.             else
  1695.             {
  1696.                 AlmExecPwrOnAlarm();
  1697.             }
  1698.         }
  1699.         else
  1700.         {
  1701.             g_alm_frm_cntx.IsPendingAlm = TRUE;
  1702.         }
  1703.     }
  1704. }
  1707. /*****************************************************************************
  1708.  * FUNCTION
  1709.  *  AlmExitPreviousAlarm
  1710.  * DESCRIPTION
  1711.  *  Execute exit handler of previous alarm to to do list alam.
  1712.  *  Exit previous alarm screen.
  1713.  * PARAMETERS
  1714.  *  void
  1715.  * RETURNS
  1716.  *  void
  1717.  *****************************************************************************/
  1718. void AlmExitPreviousAlarm(void)
  1719. {
  1720.     /*----------------------------------------------------------------*/
  1721.     /* Local Variables                                                */
  1722.     /*----------------------------------------------------------------*/
  1723.     U8 almType;
  1725.     /*----------------------------------------------------------------*/
  1726.     /* Code Body                                                      */
  1727.     /*----------------------------------------------------------------*/
  1728.     /* if some alarm is previous displayed, execute previous exit handler */
  1729.     if (g_alm_frm_cntx.CurrAlmIndex < ALM_INDEX_TOTAL)
  1730.     {
  1731.         /* stop previous alarm */
  1732.         almType = AlmGetType(g_alm_frm_cntx.CurrAlmIndex);
  1733.         if (gAlmCBHandler[almType].stopAlarmCBPtr)
  1734.         {
  1735.             gAlmCBHandler[almType].stopAlarmCBPtr();
  1736.         }
  1737.         else
  1738.         {
  1739.             StopTimer(ALARM_ALERT_NOTIFYDURATION_TIMER);
  1740.             g_alm_frm_cntx.CurrAlmIndex = 0xff;
  1741.         }
  1742.     }
  1744.     g_alm_frm_cntx.CurrAlmIndex = 0xff;
  1745. }
  1748. /*****************************************************************************
  1749.  * FUNCTION
  1750.  *  EntryAlmDummyScr
  1751.  * DESCRIPTION
  1752.  *  Dummy screen to exit previous application (Java)
  1753.  * PARAMETERS
  1754.  *  void
  1755.  * RETURNS
  1756.  *  void
  1757.  *****************************************************************************/
  1758. void EntryAlmDummyScr(void)
  1759. {
  1760.     /*----------------------------------------------------------------*/
  1761.     /* Local Variables                                                */
  1762.     /*----------------------------------------------------------------*/
  1764.     /*----------------------------------------------------------------*/
  1765.     /* Code Body                                                      */
  1766.     /*----------------------------------------------------------------*/
  1767.     EntryNewScreen(GLOBAL_SCR_DUMMY, NULL, NULL, NULL);
  1768. }
  1771. /*****************************************************************************
  1772.  * FUNCTION
  1773.  *  mmi_alm_spof_disable_check
  1774.  * DESCRIPTION
  1775.  *  SPOF disable handler
  1776.  * PARAMETERS
  1777.  *  void
  1778.  * RETURNS
  1779.  *  Expired alarm index in the queue except for SPOF
  1780.  *****************************************************************************/
  1781. U8 mmi_alm_spof_disable_check(void)
  1782. {
  1783.     /*----------------------------------------------------------------*/
  1784.     /* Local Variables                                                */
  1785.     /*----------------------------------------------------------------*/
  1786.     MYTIME currTime;
  1787.     U8 i, almIndex = 0xff;;
  1789.     /*----------------------------------------------------------------*/
  1790.     /* Code Body                                                      */
  1791.     /*----------------------------------------------------------------*/
  1792.     DTGetRTCTime(&currTime);
  1793.     g_alm_frm_cntx.IsPendingAlm = TRUE;
  1795.     /* more alarms in queue and */
  1796.     for (i=1; i<NUM_OF_SPOF && i< g_alm_frm_cntx.EnabledAlarms;i++)
  1797.     {
  1798.         if (CompareTime(gAlmQueue[i].Time, currTime, NULL) == TIME_GREATER)
  1799.         {
  1800.             AlmStartAlarmOnHW(gAlmQueue[i].Time);
  1801.             break;
  1802.         }
  1803.         else if ( AlmGetType(gAlmQueue[i].Index) != ALM_TYPE_SPOF)
  1804.         {
  1805.             almIndex = gAlmQueue[i].Index;
  1806.             break;
  1807.         }
  1808.         
  1809.     }
  1810.     
  1811.     return almIndex;
  1812. }
  1815. /*****************************************************************************
  1816.  * FUNCTION
  1817.  *  AlmExpiryHandler
  1818.  * DESCRIPTION
  1819.  *  To set alarm to RTC
  1820.  * PARAMETERS
  1821.  *  msg             [?]         
  1822.  *  index(?)        [IN]        Index of alarm
  1823.  * RETURNS
  1824.  *  void
  1825.  *****************************************************************************/
  1826. void AlmExpiryHandler(void *msg)
  1827. {
  1828. #ifdef MMI_ON_HARDWARE_P
  1829.     /*----------------------------------------------------------------*/
  1830.     /* Local Variables                                                */
  1831.     /*----------------------------------------------------------------*/
  1832.     mmi_eq_alarm_ind_struct *local_data = (mmi_eq_alarm_ind_struct*) msg;
  1834.     /*----------------------------------------------------------------*/
  1835.     /* Code Body                                                      */
  1836.     /*----------------------------------------------------------------*/
  1837.     /* update global time */
  1839.     StopTimer(ALARM_ALERT_NOTIFYDURATION_TIMER);
  1840.     StopTimer(ALARM_TIMER_WAIT_FOR_CALL);
  1842.     gclockData.rtc_wday = local_data->rtc_time.rtc_wday;
  1843.     gclockData.rtc_year = local_data->rtc_time.rtc_year;
  1844.     gclockData.rtc_mon = local_data->rtc_time.rtc_mon;
  1845.     gclockData.rtc_day = local_data->rtc_time.rtc_day;
  1846.     gclockData.rtc_hour = local_data->rtc_time.rtc_hour;
  1847.     gclockData.rtc_min = local_data->rtc_time.rtc_min;
  1848.     gclockData.rtc_sec = local_data->rtc_time.rtc_sec;
  1850.     mmi_dt_check_rtc_time();
  1852.     /* execute exit handler of previous alarm */
  1853.     g_alm_frm_cntx.IsExitByTimer = TRUE;
  1854.     AlmExitPreviousAlarm();
  1855.     g_alm_frm_cntx.IsExitByTimer = FALSE;
  1857.     if (!AlmIsExpireAllowed())
  1858.     {
  1859.         g_alm_frm_cntx.IsPendingAlm = TRUE;
  1860.         return;
  1861.     }
  1863.     if (AlmIsPowerOffMode())
  1864.     {
  1865.         g_alm_frm_cntx.IsPwronAlarm = TRUE;
  1866.     }
  1868.     /* execute next alarm */
  1869.     if (g_alm_frm_cntx.IsPwronAlarm)
  1870.     {
  1871.         AlmExecPwrOffAlarm();
  1872.     }
  1873.     else
  1874.     {
  1875.         AlmExecPwrOnAlarm();
  1876.     }
  1878. #endif /* MMI_ON_HARDWARE_P */ 
  1879. }
  1882. /*****************************************************************************
  1883.  * FUNCTION
  1884.  *  AlmExecPwrOnAlarm
  1885.  * DESCRIPTION
  1886.  *  Popup one alarm entry from queue and execute corresponding handler.
  1887.  * PARAMETERS
  1888.  *  void
  1889.  * RETURNS
  1890.  *  void
  1891.  *****************************************************************************/
  1892. void AlmExecPwrOnAlarm(void)
  1893. {
  1894. #ifdef MMI_ON_HARDWARE_P
  1895.     /*----------------------------------------------------------------*/
  1896.     /* Local Variables                                                */
  1897.     /*----------------------------------------------------------------*/
  1898.     U8 almType, almIndex;
  1899.     MYTIME currTime, alarmTime, incTime;
  1900.     TIME_EQUALITY equality;
  1901.     U8 NexAlmToShow = FALSE;
  1902.     U8 NextAlmToSet = FALSE;
  1903.     U8 AlmSnoozeTime, tmpIndex;
  1904.     U8 IsSPOFPending = FALSE;
  1905.     U16 period = 0;
  1907. #ifdef __J2ME__
  1908.     U8 IsJavaPlaying = FALSE;
  1909. #endif 
  1911.     /*----------------------------------------------------------------*/
  1912.     /* Code Body                                                      */
  1913.     /*----------------------------------------------------------------*/
  1914.     g_alm_frm_cntx.CurrAlmIndex = 0xff;
  1915.     g_alm_frm_cntx.IsPendingAlm = FALSE;
  1916.     /* no alarm expired, to prevent abnormal case */
  1917.     if (!g_alm_frm_cntx.EnabledAlarms)
  1918.     {
  1919.         MMI_TRACE((MMI_TRACE_G1_FRM, MMI_RTC_ALARM_EMPTY_QUEUE));
  1920.         g_alm_frm_cntx.IsPendingAlm = FALSE;
  1921.         return;
  1922.     }
  1924.     if (!AlmIsExpireAllowed())
  1925.     {
  1926.         g_alm_frm_cntx.IsPendingAlm = TRUE;
  1927.         return;
  1928.     }
  1930.     DTGetRTCTime(&currTime);
  1931.     /* to prevent abnormal case */
  1932.     if (CompareTime(gAlmQueue[0].Time, currTime, NULL) == TIME_GREATER)
  1933.     {
  1934.         AlmStartAlarmOnHW(gAlmQueue[0].Time);
  1935.         g_alm_frm_cntx.IsPendingAlm = FALSE;
  1936.         return;
  1937.     }
  1939.     almIndex = gAlmQueue[0].Index;
  1940.     almType = AlmGetType(almIndex);
  1942.     /* spof is disabled, find out next alarm to execute */
  1943.     if (almType == ALM_TYPE_SPOF && g_alm_frm_cntx.IsSpofDisabled)
  1944.     {
  1945.         almIndex = mmi_alm_spof_disable_check();
  1946.         if (almIndex == 0xff)   /* no other alarm expired */
  1947.         {
  1948.             return;
  1949.         }
  1950.         else
  1951.         {
  1952.             IsSPOFPending = TRUE;
  1953.             almType = AlmGetType(almIndex);
  1954.         }
  1955.     }
  1957.     g_alm_frm_cntx.CurrAlmIndex = almIndex;
  1959. #ifdef __J2ME__
  1960.     if (GetActiveScreenId() == SCR_JAVA_APP)
  1961.     {
  1962.         IsJavaPlaying = TRUE;
  1963.         jvm_pause_dummy_screen();
  1964.     }
  1965. #endif /* __J2ME__ */ 
  1967.     /* re-organizer alarm queue */
  1968.     /* if(!g_alm_frm_cntx.IsPendingAlm) */
  1969.     {
  1970.         /* if it's a pending alarm, no need to re-schedule right now */
  1971.         if (AlmGetRepeat(almIndex) == ALM_FREQ_ONCE)
  1972.         {
  1973.             AlmRemoveFromQueue(almIndex, TRUE);
  1974.         }
  1975.         else if (almType != ALM_TYPE_ALARM) /* alarm shall be inserted into queue after stopped */
  1976.         {
  1977.             AlmInsertIntoQueue(almIndex, TRUE);
  1978.         }
  1979.         else
  1980.         {
  1981.             tmpIndex = almIndex - ALM_ALM_START;
  1982.             AlmSnoozeTime = g_alm_cntx.AlmList[tmpIndex].Snooze;
  1983.             g_alm_cntx.AlmList[tmpIndex].Snooze = 0;
  1984.             AlmInsertIntoQueue(almIndex, TRUE);
  1985.             g_alm_cntx.AlmList[tmpIndex].Snooze = AlmSnoozeTime;
  1986.         }
  1987.     }
  1988. #ifdef __J2ME__
  1989.     if (IsJavaPlaying == TRUE)
  1990.     {
  1991.         jvm_resume_dummy_screen();
  1992.     }
  1993. #endif /* __J2ME__ */ 
  1994.     /* execute corrpesonding handler */
  1995.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_RTC_ALARM_EXPIRY_TYPE, (S32) almType));
  1996.     if (gAlmCBHandler[almType].expiryHandlerCBPtr)
  1997.     {
  1998.         U8 isIndSrc;
  1999.         U8 almAppIndex = g_alm_frm_cntx.CurrAlmIndex - gAlmCBHandler[almType].alarmStartIndex;
  2001.         isIndSrc = gAlmCBHandler[almType].expiryHandlerCBPtr(almAppIndex, &period, MMI_TRUE);
  2003.         if (isIndSrc == ALM_HAS_NO_IND)
  2004.         {
  2005.         }
  2006.     }
  2008.     /* set another RTC if requried */
  2009.     if (g_alm_frm_cntx.EnabledAlarms > 0)   /* second alarm exists */
  2010.     {
  2011.         memset(&incTime, 0, sizeof(MYTIME));
  2012.         incTime.nSec = period;
  2013.         IncrementTime(currTime, incTime, &alarmTime);
  2014.         equality = CompareTime(gAlmQueue[0].Time, alarmTime, NULL);
  2015.         /* if next alarm will expire within 30 seconds */
  2016.         if (equality == TIME_LESS || equality == TIME_EQUAL)    /* alarm expired */
  2017.         {
  2018.             /* increment n seconds and then set another alarm */
  2019.             NexAlmToShow = TRUE;
  2020.             NextAlmToSet = TRUE;
  2021.         }
  2022.         else
  2023.         {
  2024.             NextAlmToSet = TRUE;
  2025.             alarmTime = gAlmQueue[0].Time;
  2026.         }
  2027.         AlmStartAlarmOnHW(alarmTime);
  2028.     }
  2030.     if (period == 0)
  2031.     {
  2032.         if (g_alm_frm_cntx.EnabledAlarms)
  2033.         {
  2034.             AlmExecPwrOnAlarm();
  2035.         }
  2036.     }
  2037.     else if (!NexAlmToShow)
  2038.     {
  2039.         StartTimer(ALARM_ALERT_NOTIFYDURATION_TIMER, (period * 1000), AlmHandleAlarmTimeout);
  2040.     }
  2041. #endif /* MMI_ON_HARDWARE_P */ 
  2042. }
  2045. /*****************************************************************************
  2046.  * FUNCTION
  2047.  *  AlmExecPwrOffAlarm
  2048.  * DESCRIPTION
  2049.  *  RTC power on handler
  2050.  * PARAMETERS
  2051.  *  void
  2052.  * RETURNS
  2053.  *  void
  2054.  *****************************************************************************/
  2055. void AlmExecPwrOffAlarm(void)
  2056. {
  2057.     /*----------------------------------------------------------------*/
  2058.     /* Local Variables                                                */
  2059.     /*----------------------------------------------------------------*/
  2060.     U8 almType, almIndex;
  2061.     MYTIME currTime, alarmTime, incTime;
  2062.     TIME_EQUALITY equality;
  2063.     U8 NexAlmToShow = FALSE;
  2064.     U8 NextAlmToSet = FALSE;
  2065.     U16 period;
  2067.     /*----------------------------------------------------------------*/
  2068.     /* Code Body                                                      */
  2069.     /*----------------------------------------------------------------*/
  2070.     /* no alarm expired, to prevent abnormal case */
  2071.     StopTimer(ALARM_ALERT_NOTIFYDURATION_TIMER);
  2072.     g_alm_frm_cntx.CurrAlmIndex = 0xff;
  2073.     g_alm_frm_cntx.IsPwronAlarm = TRUE;
  2075. #ifdef MMI_ON_WIN32
  2076.     EntryAlmIndicationScreen();
  2077.     return;
  2078. #endif /* MMI_ON_WIN32 */ 
  2080.     if (!g_alm_frm_cntx.EnabledAlarms)
  2081.     {
  2082.         MMI_TRACE((MMI_TRACE_G1_FRM, MMI_RTC_ALARM_EMPTY_QUEUE));
  2083.     #ifdef MMI_ON_HARDWARE_P
  2084.         if (g_alm_frm_cntx.IsAppExecuting == 0)
  2085.         {   
  2086.             AlmSendPowerOff();
  2087.         }
  2088.     #endif 
  2089.         return;
  2090.     }
  2092.     /* compare the time */
  2093.     almIndex = gAlmQueue[0].Index;
  2094.     DTGetRTCTime(&currTime);
  2095.     if (CompareTime(gAlmQueue[0].Time, currTime, NULL) == TIME_GREATER)
  2096.     {
  2097.         g_alm_frm_cntx.IsWaitForPwroff = TRUE;
  2098.         AlmStartAlarmOnHW(gAlmQueue[0].Time);
  2099.         return;
  2100.     }
  2102.     almType = AlmGetType(almIndex);
  2103.     g_alm_frm_cntx.CurrAlmIndex = almIndex;
  2105.     /* spof is disabled, find out next alarm to execute */
  2106.     if (almType == ALM_TYPE_SPOF && g_alm_frm_cntx.IsSpofDisabled)
  2107.     {
  2108.         AlmInsertIntoQueue(almIndex, TRUE);
  2109.         if (CompareTime(gAlmQueue[0].Time, currTime, NULL) == TIME_GREATER)
  2110.         {
  2111.          AlmStartAlarmOnHW(gAlmQueue[0].Time);
  2112.         }
  2113.         else
  2114.         {
  2115.          AlmExecPwrOffAlarm();
  2116.         }
  2117.         return;        
  2118.     }
  2120.     if (AlmGetRepeat(almIndex) == ALM_FREQ_ONCE)
  2121.     {
  2122.         AlmRemoveFromQueue(almIndex, TRUE);
  2123.     }
  2124.     else if (almType != ALM_TYPE_ALARM) /* alarm shall be inserted into queue after stopped */
  2125.     {
  2126.         AlmInsertIntoQueue(almIndex, TRUE);
  2127.     }
  2128.     else
  2129.     {
  2130.         U8 tmpIndex, AlmSnoozeTime;
  2132.         tmpIndex = almIndex - ALM_ALM_START;
  2133.         AlmSnoozeTime = g_alm_cntx.AlmList[tmpIndex].Snooze;
  2134.         g_alm_cntx.AlmList[tmpIndex].Snooze = 0;
  2135.         AlmInsertIntoQueue(almIndex, TRUE);
  2136.         g_alm_cntx.AlmList[tmpIndex].Snooze = AlmSnoozeTime;
  2137.     }
  2139.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_RTC_ALARM_EXPIRY_TYPE, (S32) almType));
  2141.     if (gAlmCBHandler[almType].expiryHandlerCBPtr)
  2142.     {
  2143.         U8 almAppIndex = g_alm_frm_cntx.CurrAlmIndex - gAlmCBHandler[almType].alarmStartIndex;
  2145.         gAlmCBHandler[almType].expiryHandlerCBPtr(almAppIndex, &period, MMI_FALSE);
  2146.     }
  2148.     if (g_alm_frm_cntx.EnabledAlarms > 0)   /* second alarm exists */
  2149.     {
  2150.         /* increment 30 seconds and then set another alarm */
  2151.         memset(&incTime, 0, sizeof(MYTIME));
  2152.         incTime.nSec = period;
  2153.         IncrementTime(currTime, incTime, &alarmTime);
  2155.         equality = CompareTime(gAlmQueue[0].Time, alarmTime, NULL);
  2156.         if (equality == TIME_LESS || equality == TIME_EQUAL)    /* alarm expired */
  2157.         {
  2158.             NexAlmToShow = TRUE;
  2159.             NextAlmToSet = TRUE;
  2160.         }
  2161.         else
  2162.         {
  2163.             alarmTime = gAlmQueue[0].Time;
  2164.             NextAlmToSet = TRUE;
  2165.         }
  2166.         AlmStartAlarmOnHW(alarmTime);
  2167.     }
  2169.     if (period == 0)
  2170.     {
  2171.      /* power on/off need not execute next alarm */
  2172.         if (almType != ALM_TYPE_SPOF && almType != ALM_TYPE_SPON && almType != ALM_TYPE_PWR_RESET)
  2173.         {
  2174.             AlmExecPwrOffAlarm();
  2175.         }
  2176.     }
  2177.     else if (!NexAlmToShow)
  2178.     {
  2179.         StartTimer(ALARM_ALERT_NOTIFYDURATION_TIMER, (period * 1000), AlmHandleAlarmTimeout);
  2180.     }
  2182. }
  2185. /*****************************************************************************
  2186.  * FUNCTION
  2187.  *  AlmWriteQueueToNvram
  2188.  * DESCRIPTION
  2189.  *  Write alarm queue to nvram.
  2190.  * PARAMETERS
  2191.  *  void
  2192.  * RETURNS
  2193.  *  void
  2194.  *****************************************************************************/
  2195. void AlmWriteQueueToNvram(void)
  2196. {
  2197.     /*----------------------------------------------------------------*/
  2198.     /* Local Variables                                                */
  2199.     /*----------------------------------------------------------------*/
  2200.     S16 error;
  2202.     /*----------------------------------------------------------------*/
  2203.     /* Code Body                                                      */
  2204.     /*----------------------------------------------------------------*/
  2205.     WriteRecord(NVRAM_EF_ALM_QUEUE_LID, (U16) 1, (void*)gAlmQueue, NVRAM_ALM_QUEUE_SIZE, &error);
  2206. }
  2209. /*****************************************************************************
  2210.  * FUNCTION
  2211.  *  AlmInitQueue
  2212.  * DESCRIPTION
  2213.  *  Read alarm queue from nvram.
  2214.  *  Reset alarm queue if
  2215.  *  1. index misordered.
  2216.  *  2. the expired time of first alarm is far from current time.
  2217.  * PARAMETERS
  2218.  *  void
  2219.  * RETURNS
  2220.  *  void
  2221.  *****************************************************************************/
  2222. void AlmInitQueue(void)
  2223. {
  2224.     /*----------------------------------------------------------------*/
  2225.     /* Local Variables                                                */
  2226.     /*----------------------------------------------------------------*/
  2227.     S16 error;
  2228.     MYTIME currTime, refTime;
  2230.     /*----------------------------------------------------------------*/
  2231.     /* Code Body                                                      */
  2232.     /*----------------------------------------------------------------*/
  2233.     ReadRecord(NVRAM_EF_ALM_QUEUE_LID, (U16) 1, (void*)gAlmQueue, NVRAM_ALM_QUEUE_SIZE, &error);
  2235.     if (gAlmQueue[0].Index >= ALM_INDEX_TOTAL /* && gAlmQueue[0].Index != 0xff */ )     /* o prevent alarm queue being corrupted */
  2236.     {
  2237.         AlmReInitialize();
  2238.     }
  2239.     else
  2240.     {
  2241.         memset(&refTime, 0, sizeof(MYTIME));
  2242.         refTime.nMin = ALM_MAX_DELAY_ALLOWANCE;
  2243.         IncrementTime(gAlmQueue[0].Time, refTime, &refTime);
  2245.         DTGetRTCTime(&currTime);
  2247.         if (CompareTime(currTime, refTime, NULL) == TIME_GREATER)
  2248.         {
  2249.             AlmReInitialize();
  2250.         }
  2251.     }
  2252. }
  2255. /*****************************************************************************
  2256.  * FUNCTION
  2257.  *  AlmFindNodeInQueue
  2258.  * DESCRIPTION
  2259.  *  To see if the alarm node is currently in alarm queue
  2260.  * PARAMETERS
  2261.  *  index       [IN]        Index of alarm
  2262.  * RETURNS
  2263.  *  0xff is the node is not in queue; otherwise, return the position of the alarm node.
  2264.  *****************************************************************************/
  2265. U8 AlmFindNodeInQueue(U8 index)
  2266. {
  2267.     /*----------------------------------------------------------------*/
  2268.     /* Local Variables                                                */
  2269.     /*----------------------------------------------------------------*/
  2270.     U8 i;
  2272.     /*----------------------------------------------------------------*/
  2273.     /* Code Body                                                      */
  2274.     /*----------------------------------------------------------------*/
  2275.     for (i = 0; i < NUM_OF_ALM; i++)
  2276.     {
  2277.         if (gAlmQueue[i].Index == index)
  2278.         {
  2279.             return i;
  2280.         }
  2282.         if (gAlmQueue[i].Index > ALM_INDEX_TOTAL)
  2283.         {
  2284.             return 0xff;
  2285.         }
  2286.     }
  2287.     return 0;
  2288. }
  2291. /*****************************************************************************
  2292.  * FUNCTION
  2293.  *  AlmGetType
  2294.  * DESCRIPTION
  2295.  *  To get the type of alarm
  2296.  * PARAMETERS
  2297.  *  index       [IN]        Index of alarm
  2298.  * RETURNS
  2299.  *  Enum value of alarm type
  2300.  *****************************************************************************/
  2301. U8 AlmGetType(U8 index)
  2302. {
  2303.     /*----------------------------------------------------------------*/
  2304.     /* Local Variables                                                */
  2305.     /*----------------------------------------------------------------*/
  2306.     U8 i;
  2308.     /*----------------------------------------------------------------*/
  2309.     /* Code Body                                                      */
  2310.     /*----------------------------------------------------------------*/
  2311.     for (i = 1; i < ALM_TYPE_TOTAL_NUM; i++)
  2312.     {
  2313.         if (index < gAlmCBHandler[i].alarmStartIndex)
  2314.         {
  2315.             break;
  2316.         }
  2317.     }
  2318.     return i - 1;
  2319. }
  2322. /*****************************************************************************
  2323.  * FUNCTION
  2324.  *  AlmGetRepeat
  2325.  * DESCRIPTION
  2326.  *  To get the repeat type of an alarm.
  2327.  * PARAMETERS
  2328.  *  index       [IN]        Index of alarm
  2329.  * RETURNS
  2330.  *  Enum value of repeat type
  2331.  *****************************************************************************/
  2332. U8 AlmGetRepeat(U8 index)
  2333. {
  2334.     /*----------------------------------------------------------------*/
  2335.     /* Local Variables                                                */
  2336.     /*----------------------------------------------------------------*/
  2337.     MYTIME alarmTime, preReminder;
  2338.     U8 Freq = 0;
  2339.     U8 WeekDays = 0;
  2340.     U8 AlmType, AlmIndex;
  2342.     /*----------------------------------------------------------------*/
  2343.     /* Code Body                                                      */
  2344.     /*----------------------------------------------------------------*/
  2345.     memset(&preReminder, 0, sizeof(MYTIME));
  2346.     AlmType = AlmGetType(index);
  2347.     AlmIndex = index - gAlmCBHandler[AlmType].alarmStartIndex;
  2348.     if (gAlmCBHandler[AlmType].expiryTimeCBPtr)
  2349.     {
  2350.         gAlmCBHandler[AlmType].expiryTimeCBPtr(AlmIndex, &alarmTime, &Freq, &WeekDays, &preReminder);
  2351.     }
  2352.     return Freq;
  2353. }
  2356. /*****************************************************************************
  2357.  * FUNCTION
  2358.  *  AlmGetStringValue
  2359.  * DESCRIPTION
  2360.  *  Compute the string value of given integer. The string will dispaly exact 2 digits.
  2361.  * PARAMETERS
  2362.  *  StringVal       [IN/OUT]        Pointer to store the result.
  2363.  *  Val             [IN]            Value to be computed
  2364.  * RETURNS
  2365.  *  void
  2366.  *****************************************************************************/
  2367. void AlmGetStringValue(S8 *StringVal, U8 Val)
  2368. {
  2369.     /*----------------------------------------------------------------*/
  2370.     /* Local Variables                                                */
  2371.     /*----------------------------------------------------------------*/
  2372.     S8 StrVal[16];
  2374.     /*----------------------------------------------------------------*/
  2375.     /* Code Body                                                      */
  2376.     /*----------------------------------------------------------------*/
  2377.     sprintf(StrVal, "%02d", Val);
  2378.     AnsiiToUnicodeString(StringVal, StrVal);
  2379. }
  2382. /*****************************************************************************
  2383.  * FUNCTION
  2384.  *  AlmIsRTCPwron
  2385.  * DESCRIPTION
  2386.  *  To see if the it's RTC power on or not.
  2387.  * PARAMETERS
  2388.  *  void
  2389.  * RETURNS
  2390.  *  The state of power on alarm.
  2391.  *****************************************************************************/
  2392. U8 AlmIsRTCPwron(void)
  2393. {
  2394.     /*----------------------------------------------------------------*/
  2395.     /* Local Variables                                                */
  2396.     /*----------------------------------------------------------------*/
  2398.     /*----------------------------------------------------------------*/
  2399.     /* Code Body                                                      */
  2400.     /*----------------------------------------------------------------*/
  2401.     return g_alm_frm_cntx.IsPwronAlarm;
  2402. }
  2405. /*****************************************************************************
  2406.  * FUNCTION
  2407.  *  AlmStartAlarmOnHW
  2408.  * DESCRIPTION
  2409.  *  To register RTC alarm on HW
  2410.  * PARAMETERS
  2411.  *  alarmTime       [IN]        
  2412.  * RETURNS
  2413.  *  void
  2414.  *****************************************************************************/
  2415. void AlmStartAlarmOnHW(MYTIME alarmTime)
  2416. {
  2417. #ifdef MMI_ON_HARDWARE_P
  2418.     /*----------------------------------------------------------------*/
  2419.     /* Local Variables                                                */
  2420.     /*----------------------------------------------------------------*/
  2421.     MYQUEUE Message;
  2422.     mmi_eq_set_rtc_time_req_struct *alarmReq;
  2424.     /*----------------------------------------------------------------*/
  2425.     /* Code Body                                                      */
  2426.     /*----------------------------------------------------------------*/
  2427.     Message.oslSrcId = MOD_MMI;
  2428.     Message.oslDestId = MOD_L4C;
  2429.     Message.oslMsgId = MSG_ID_MMI_EQ_EXE_RTC_TIMER_REQ;
  2430.     alarmReq = (mmi_eq_set_rtc_time_req_struct*) OslConstructDataPtr(sizeof(mmi_eq_set_rtc_time_req_struct));
  2431.     alarmReq->rtc_type = RTC_ALARM_IND;
  2432.     alarmReq->set_type = RTC_SETTING_TYPE_DATETIME;
  2433.     alarmReq->info.alarm_format = DEVICE_AL_EN_ChkYMDHMS;
  2434.     alarmReq->info.alarm_index = RTC_ALARM1_IND;    /* Should be always zeor as only 1 alarm */
  2435.     alarmReq->info.type = RTC_ALARM_SOUND;
  2436.     alarmReq->info.text[0] = '';
  2437.     alarmReq->info.recurr = RTC_ALARM_DAY1;
  2438.     alarmReq->info.data_time.rtc_year = alarmTime.nYear - YEARFORMATE;
  2439.     alarmReq->info.data_time.rtc_wday = alarmTime.DayIndex;
  2440.     alarmReq->info.data_time.rtc_mon = alarmTime.nMonth;
  2441.     alarmReq->info.data_time.rtc_day = alarmTime.nDay;
  2442.     alarmReq->info.data_time.rtc_hour = alarmTime.nHour;
  2443.     alarmReq->info.data_time.rtc_min = alarmTime.nMin;
  2444.     alarmReq->info.data_time.rtc_sec = alarmTime.nSec;
  2445.     Message.oslDataPtr = (oslParaType*) alarmReq;
  2446.     Message.oslPeerBuffPtr = NULL;
  2448.     SetProtocolEventHandler(AlmSetAlarmRSP, MSG_ID_MMI_EQ_EXE_RTC_TIMER_RSP);
  2449.     ClearProtocolEventHandler(MSG_ID_MMI_EQ_ALARM_IND);
  2450.     OslMsgSendExtQueue(&Message);
  2451. #endif /* MMI_ON_HARDWARE_P */ 
  2452. #if 0
  2453. /* under construction !*/
  2454. /* under construction !*/
  2455. /* under construction !*/
  2456. /* under construction !*/
  2457. /* under construction !*/
  2458. /* under construction !*/
  2459. /* under construction !*/
  2460. /* under construction !*/
  2461. /* under construction !*/
  2462. /* under construction !*/
  2463. /* under construction !*/
  2464. /* under construction !*/
  2465. /* under construction !*/
  2466. /* under construction !*/
  2467. /* under construction !*/
  2468. /* under construction !*/
  2469. /* under construction !*/
  2470. /* under construction !*/
  2471. /* under construction !*/
  2472. /* under construction !*/
  2473. /* under construction !*/
  2474. /* under construction !*/
  2475. /* under construction !*/
  2476. /* under construction !*/
  2477. /* under construction !*/
  2478. /* under construction !*/
  2479. /* under construction !*/
  2480. /* under construction !*/
  2481. /* under construction !*/
  2482. #endif /* 0 */ 
  2483. }
  2486. /*****************************************************************************
  2487.  * FUNCTION
  2488.  *  AlmStopAlarmOnHW
  2489.  * DESCRIPTION
  2490.  *  To del RTC from HW.
  2491.  * PARAMETERS
  2492.  *  void
  2493.  * RETURNS
  2494.  *  void
  2495.  *****************************************************************************/
  2496. void AlmStopAlarmOnHW(void)
  2497. {
  2498. #ifdef MMI_ON_HARDWARE_P
  2499.     /*----------------------------------------------------------------*/
  2500.     /* Local Variables                                                */
  2501.     /*----------------------------------------------------------------*/
  2502.     MYQUEUE Message;
  2504.     mmi_eq_del_rtc_timer_req_struct *alarmReq;
  2506.     /*----------------------------------------------------------------*/
  2507.     /* Code Body                                                      */
  2508.     /*----------------------------------------------------------------*/
  2509.     Message.oslSrcId = MOD_MMI;
  2510.     Message.oslDestId = MOD_L4C;
  2512.     Message.oslMsgId = MSG_ID_MMI_EQ_EXE_DEL_RTC_TIMER_REQ;
  2514.     alarmReq = (mmi_eq_del_rtc_timer_req_struct*) OslConstructDataPtr(sizeof(mmi_eq_del_rtc_timer_req_struct));
  2516.     alarmReq->rtc_type = RTC_ALARM_IND;
  2517.     alarmReq->rtc_index = RTC_ALARM1_IND;
  2518.     /* MTK end */
  2519.     Message.oslDataPtr = (oslParaType*) alarmReq;
  2520.     Message.oslPeerBuffPtr = NULL;
  2521.     SetProtocolEventHandler(AlmCancelAlarmRsp, MSG_ID_MMI_EQ_EXE_DEL_RTC_TIMER_RSP);
  2522.     ClearProtocolEventHandler(MSG_ID_MMI_EQ_ALARM_IND);
  2524.     OslMsgSendExtQueue(&Message);
  2525. #else /* MMI_ON_HARDWARE_P */ 
  2526.     StopTimer(ALARM_SIMULATE_ON_WIN32);
  2527. #endif /* MMI_ON_HARDWARE_P */ 
  2529. }
  2532. /*****************************************************************************
  2533.  * FUNCTION
  2534.  *  AlmReInitialize
  2535.  * DESCRIPTION
  2536.  *  Re construct whole alarm queue and realted variables.
  2537.  * PARAMETERS
  2538.  *  void
  2539.  * RETURNS
  2540.  *  The state of power on alarm.(?)
  2541.  *****************************************************************************/
  2542. void AlmReInitialize(void)
  2543. {
  2544.     /*----------------------------------------------------------------*/
  2545.     /* Local Variables                                                */
  2546.     /*----------------------------------------------------------------*/
  2547.     S32 i, almPreviousState;
  2549.     /*----------------------------------------------------------------*/
  2550.     /* Code Body                                                      */
  2551.     /*----------------------------------------------------------------*/
  2552.     almPreviousState = g_alm_frm_cntx.IsExpiryDisabled;
  2553.     
  2554.     AlmDisableExpiryHandler();
  2556.     AlmStopAlarmOnHW();
  2558.     memset(gAlmQueue, 0xff, sizeof(gAlmQueue));
  2560.     g_alm_frm_cntx.EnabledAlarms = 0;
  2562.     for (i = 0; i < ALM_TYPE_TOTAL_NUM; i++)
  2563.     {
  2564.         if (gAlmCBHandler[i].reInitAlarmQueueCBPtr)
  2565.         {
  2566.             gAlmCBHandler[i].reInitAlarmQueueCBPtr();
  2567.         }
  2568.     }
  2570.     AlmWriteQueueToNvram();
  2572.     if (gAlmQueue[0].Index != 0xff)
  2573.     {
  2574.         AlmStartAlarmOnHW(gAlmQueue[0].Time);
  2575.     }
  2577.     if (almPreviousState == MMI_FALSE)
  2578.     {
  2579.         AlmEnableExpiryHandler();
  2580.     }
  2581. }
  2584. /*****************************************************************************
  2585.  * FUNCTION
  2586.  *  AlmSendPowerOn
  2587.  * DESCRIPTION
  2588.  *  Display check disk screen, reset language, then send power on request.
  2589.  * PARAMETERS
  2590.  *  void
  2591.  * RETURNS
  2592.  *  void
  2593.  *****************************************************************************/
  2594. void AlmSendPowerOn(void)
  2595. {
  2596.     /*----------------------------------------------------------------*/
  2597.     /* Local Variables                                                */
  2598.     /*----------------------------------------------------------------*/
  2600.     /*----------------------------------------------------------------*/
  2601.     /* Code Body                                                      */
  2602.     /*----------------------------------------------------------------*/
  2603.     AlmsStopAlarmTone();
  2604.     EntryNewScreen(GLOBAL_SCR_DUMMY, NULL, NULL, NULL);
  2605.     ClearKeyHandler(KEY_END, KEY_EVENT_DOWN);
  2606.     ClearKeyHandler(KEY_END, KEY_LONG_PRESS);
  2607.     ResetLanguageSettingFlag();
  2608. #ifdef __NVRAM_IN_USB_MS__
  2609.     if (g_pwr_context.PowerOnMode == POWER_ON_USB)
  2610.     {
  2611.         /* Temporily disable alarm reset in USB boot mode */
  2612.         /*
  2613.          * mmi_usb_set_reset_type(ALARM_RESET);
  2614.          */
  2615.         UsbPwnOnThenPwnOn();
  2616.     }
  2617.     else
  2618. #endif /* __NVRAM_IN_USB_MS__ */ 
  2619.     {
  2620.         MMICheckDiskDisplay();
  2621.         AlmSendPwronReq();
  2622.     }
  2623.     /* turn on backlight to make logo visible for the user */
  2624.     TurnOnBacklight(TRUE);
  2625. }
  2628. /*****************************************************************************
  2629.  * FUNCTION
  2630.  *  AlmSendPowerOff
  2631.  * DESCRIPTION
  2632.  *  Send power off request.
  2633.  * PARAMETERS
  2634.  *  void
  2635.  * RETURNS
  2636.  *  void
  2637.  *****************************************************************************/
  2638. void AlmSendPowerOff(void)
  2639. {
  2640.     /*----------------------------------------------------------------*/
  2641.     /* Local Variables                                                */
  2642.     /*----------------------------------------------------------------*/
  2644.     /*----------------------------------------------------------------*/
  2645.     /* Code Body                                                      */
  2646.     /*----------------------------------------------------------------*/
  2647.     AlmCommonExitProcedure();
  2648. #ifdef __NVRAM_IN_USB_MS__
  2649.     if (g_pwr_context.PowerOnMode == POWER_ON_USB)
  2650.     {
  2651.         mmi_usb_set_reset_type(CHARGING_RESET);
  2652.         UsbPwnOnThenPwnOn();
  2653.     }
  2654.     else
  2655. #endif /* __NVRAM_IN_USB_MS__ */ 
  2656.         QuitSystemOperation();
  2657. }
  2660. /*****************************************************************************
  2661.  * FUNCTION
  2662.  *  AlmCheckAlarmState
  2663.  * DESCRIPTION
  2664.  *  If first alarm time > currTime, start first alarm on hardware.
  2665.  *  Else, set flag to indicate there is some pending alarm.
  2666.  * PARAMETERS
  2667.  *  void
  2668.  * RETURNS
  2669.  *  void
  2670.  *****************************************************************************/
  2671. void AlmCheckAlarmState(void)
  2672. {
  2673.     /*----------------------------------------------------------------*/
  2674.     /* Local Variables                                                */
  2675.     /*----------------------------------------------------------------*/
  2676.     MYTIME currTime;
  2678.     /*----------------------------------------------------------------*/
  2679.     /* Code Body                                                      */
  2680.     /*----------------------------------------------------------------*/
  2681.     DTGetRTCTime(&currTime);
  2683.     if (CompareTime(gAlmQueue[0].Time, currTime, NULL) == TIME_GREATER)
  2684.     {
  2685.         AlmStartAlarmOnHW(gAlmQueue[0].Time);
  2686.     }
  2687.     else
  2688.     {
  2689.         g_alm_frm_cntx.IsPendingAlm = TRUE;
  2690.     }
  2691. }
  2694. /*****************************************************************************
  2695.  * FUNCTION
  2696.  *  AlmHandlePendingTimeout
  2697.  * DESCRIPTION
  2698.  *  Execute pending alarm
  2699.  * PARAMETERS
  2700.  *  void
  2701.  * RETURNS
  2702.  *  void
  2703.  *****************************************************************************/
  2704. void AlmHandlePendingTimeout(void)
  2705. {
  2706.     /*----------------------------------------------------------------*/
  2707.     /* Local Variables                                                */
  2708.     /*----------------------------------------------------------------*/
  2710.     /*----------------------------------------------------------------*/
  2711.     /* Code Body                                                      */
  2712.     /*----------------------------------------------------------------*/
  2713.     if (!AlmIsExpireAllowed())
  2714.     {
  2715.         g_alm_frm_cntx.IsPendingAlm = TRUE;
  2716.     }
  2717.     else
  2718.     {
  2719.         U8 almType;
  2721.         MMI_TRACE((MMI_TRACE_G1_FRM, MMI_RTC_ALARM_PENDING_TIMEOUT));
  2723.         almType = AlmGetType(g_alm_frm_cntx.CurrAlmIndex);
  2725.         /* stop previous alarm */
  2726.         AlmExitPreviousAlarm();
  2728.         if (almType != ALM_TYPE_ALARM)
  2729.         {
  2730.             /* alarm will be executed in the snooze handler. */
  2731.             if (AlmIsPowerOffMode())
  2732.             {
  2733.                 AlmExecPwrOffAlarm();
  2734.             }
  2735.             else
  2736.             {
  2737.                 AlmExecPwrOnAlarm();
  2738.             }
  2739.         }
  2740.     }
  2741. }
  2744. /*****************************************************************************
  2745.  * FUNCTION
  2746.  *  AlmDisableSPOF
  2747.  * DESCRIPTION
  2748.  *  Disable schedule power off functionality.
  2749.  * PARAMETERS
  2750.  *  void
  2751.  * RETURNS
  2752.  *  void
  2753.  *****************************************************************************/
  2754. void AlmDisableSPOF(void)
  2755. {
  2756.     /*----------------------------------------------------------------*/
  2757.     /* Local Variables                                                */
  2758.     /*----------------------------------------------------------------*/
  2760.     /*----------------------------------------------------------------*/
  2761.     /* Code Body                                                      */
  2762.     /*----------------------------------------------------------------*/
  2763.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_RTC_ALARM_DISABLE_SPOF));
  2764.     g_alm_frm_cntx.IsSpofDisabled = TRUE;
  2765. }
  2768. /*****************************************************************************
  2769.  * FUNCTION
  2770.  *  AlmEnableSPOF
  2771.  * DESCRIPTION
  2772.  *  Enable schedule power off functionality.
  2773.  * PARAMETERS
  2774.  *  void
  2775.  * RETURNS
  2776.  *  void
  2777.  *****************************************************************************/
  2778. void AlmEnableSPOF(void)
  2779. {
  2780.     /*----------------------------------------------------------------*/
  2781.     /* Local Variables                                                */
  2782.     /*----------------------------------------------------------------*/
  2784.     /*----------------------------------------------------------------*/
  2785.     /* Code Body                                                      */
  2786.     /*----------------------------------------------------------------*/
  2787.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_RTC_ALARM_ENABLE_SPOF));
  2788.     if (g_alm_frm_cntx.IsSpofDisabled)
  2789.     {
  2790.         g_alm_frm_cntx.IsSpofDisabled = FALSE;
  2791.         PendingAlarmReminder();
  2792.     }
  2793. }
  2796. /*****************************************************************************
  2797.  * FUNCTION
  2798.  *  AlmDisableExpiryHandler
  2799.  * DESCRIPTION
  2800.  *  Disable alarm epxiry handler.
  2801.  * PARAMETERS
  2802.  *  void
  2803.  * RETURNS
  2804.  *  void
  2805.  *****************************************************************************/
  2806. void AlmDisableExpiryHandler(void)
  2807. {
  2808.     /*----------------------------------------------------------------*/
  2809.     /* Local Variables                                                */
  2810.     /*----------------------------------------------------------------*/
  2812.     /*----------------------------------------------------------------*/
  2813.     /* Code Body                                                      */
  2814.     /*----------------------------------------------------------------*/
  2815.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_RTC_ALARM_DISABLE_ALARM));
  2816.     g_alm_frm_cntx.IsExpiryDisabled = TRUE;
  2817. }
  2820. /*****************************************************************************
  2821.  * FUNCTION
  2822.  *  AlmEnableExpiryHandler
  2823.  * DESCRIPTION
  2824.  *  Enable alarm epxiry handler.
  2825.  * PARAMETERS
  2826.  *  void
  2827.  * RETURNS
  2828.  *  void
  2829.  *****************************************************************************/
  2830. void AlmEnableExpiryHandler(void)
  2831. {
  2832.     /*----------------------------------------------------------------*/
  2833.     /* Local Variables                                                */
  2834.     /*----------------------------------------------------------------*/
  2836.     /*----------------------------------------------------------------*/
  2837.     /* Code Body                                                      */
  2838.     /*----------------------------------------------------------------*/
  2839.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_RTC_ALARM_ENABLE_ALARM));
  2840.     if (g_alm_frm_cntx.IsExpiryDisabled)
  2841.     {
  2842.         g_alm_frm_cntx.IsExpiryDisabled = FALSE;
  2843.         PendingAlarmReminder();
  2844.     }
  2845. }
  2848. /*****************************************************************************
  2849.  * FUNCTION
  2850.  *  AlmDeInit
  2851.  * DESCRIPTION
  2852.  *  Inspec queue status and pre-set next alarm if required.
  2853.  * PARAMETERS
  2854.  *  void
  2855.  * RETURNS
  2856.  *  void
  2857.  *****************************************************************************/
  2858. void AlmDeInit(void)
  2859. {
  2860. #ifdef MMI_ON_HARDWARE_P
  2861.     /*----------------------------------------------------------------*/
  2862.     /* Local Variables                                                */
  2863.     /*----------------------------------------------------------------*/
  2865.     /*----------------------------------------------------------------*/
  2866.     /* Code Body                                                      */
  2867.     /*----------------------------------------------------------------*/
  2868.     /* shutdown when alarm is on indication screen */
  2869.     if (AlmGetType(g_alm_frm_cntx.CurrAlmIndex) == ALM_TYPE_ALARM)
  2870.     {
  2871.         U8 i = g_alm_frm_cntx.CurrAlmIndex - ALM_ALM_START;
  2873.         g_alm_cntx.AlmList[i].Snooze++;
  2875.         if (g_alm_cntx.AlmList[i].Snooze <= MAX_SNOOZE_CHANCES)
  2876.         {
  2877.             AlmWriteToNvram();
  2878.             AlmInsertIntoQueue(g_alm_frm_cntx.CurrAlmIndex, TRUE);
  2879.             AlmStartAlarmOnHW(gAlmQueue[0].Time);
  2880.         }
  2881.     }
  2883.     /* Set next alarm. if alarm will expire during power off period, delay it */
  2884.     if (gAlmQueue[0].Index < ALM_INDEX_TOTAL)
  2885.     {
  2886.         MYTIME currTime, incTime;
  2888.         DTGetRTCTime(&currTime);
  2890.         memset(&incTime, 0, sizeof(MYTIME));
  2891.         incTime.nSec = (ALM_POWER_OFF_TOLERANCE / 1000);
  2893.         IncrementTime(currTime, incTime, &currTime);
  2895.         if (CompareTime(gAlmQueue[0].Time, currTime, NULL) != TIME_GREATER)     /* alarm almost expire */
  2896.         {
  2897.             AlmStartAlarmOnHW(currTime);
  2898.         }
  2899.     }
  2900. #endif /* MMI_ON_HARDWARE_P */ 
  2901. }
  2904. /*****************************************************************************
  2905.  * FUNCTION
  2906.  *  AlmIsTonePlaying
  2907.  * DESCRIPTION
  2908.  *  Query if alarm tone playing.
  2909.  * PARAMETERS
  2910.  *  void
  2911.  * RETURNS
  2912.  *  void
  2913.  *****************************************************************************/
  2914. U8 AlmIsTonePlaying(void)
  2915. {
  2916.     /*----------------------------------------------------------------*/
  2917.     /* Local Variables                                                */
  2918.     /*----------------------------------------------------------------*/
  2920.     /*----------------------------------------------------------------*/
  2921.     /* Code Body                                                      */
  2922.     /*----------------------------------------------------------------*/
  2923.     return g_alm_frm_cntx.IsAlmTonePlaying;
  2924. }
  2926. /*****************************************************************************
  2927.  * FUNCTION
  2928.  *  mmi_alm_is_in_alarm
  2929.  * DESCRIPTION
  2930.  *  Query if alarm tone playing.
  2931.  * PARAMETERS
  2932.  *  void
  2933.  * RETURNS
  2934.  *  void
  2935.  *****************************************************************************/
  2936. MMI_BOOL mmi_alm_is_in_alarm(void)
  2937. {
  2938.     if ( AlmIsTonePlaying()
  2939. #if defined(__MMI_FM_RADIO_SCHEDULE_REC__)    
  2940.      || mmi_fmsr_is_schedule_rec_running()
  2941. #endif     
  2942.      )
  2943.     {
  2944. return MMI_TRUE;
  2945.     }
  2946.     return MMI_FALSE;
  2947. }
  2949. /*****************************************************************************
  2950.  * FUNCTION
  2951.  *  FactorySetAlarm
  2952.  * DESCRIPTION
  2953.  *  Set facrtory mode alarm.
  2954.  * PARAMETERS
  2955.  *  sec     [IN]        
  2956.  * RETURNS
  2957.  *  void
  2958.  *****************************************************************************/
  2959. #if (defined(MMI_ON_HARDWARE_P) && defined(__MMI_FACTORY_MODE__))       /* Robin Add 1001 for MMI Feature */
  2960. void FactorySetAlarm(U8 sec)
  2961. {
  2962.     /*----------------------------------------------------------------*/
  2963.     /* Local Variables                                                */
  2964.     /*----------------------------------------------------------------*/
  2966.     /*----------------------------------------------------------------*/
  2967.     /* Code Body                                                      */
  2968.     /*----------------------------------------------------------------*/
  2969.     AlmSetAlarm(ALM_FACTORY);
  2970. }
  2973. /*****************************************************************************
  2974.  * FUNCTION
  2975.  *  FactoryExpiryTimeCB
  2976.  * DESCRIPTION
  2977.  *  Set facrtory mode alarm.
  2978.  * PARAMETERS
  2979.  *  index           [IN]        
  2980.  *  alarmTime       [?]         
  2981.  *  Freq            [?]         
  2982.  *  WeekDays        [?]         
  2983.  * RETURNS
  2984.  *  void
  2985.  *****************************************************************************/
  2986. void FactoryExpiryTimeCB(U8 index, MYTIME *alarmTime, U8 *Freq, U8 *WeekDays, MYTIME *preReminder)
  2987. {
  2988.     /*----------------------------------------------------------------*/
  2989.     /* Local Variables                                                */
  2990.     /*----------------------------------------------------------------*/
  2991.     MYTIME incTime;
  2993.     /*----------------------------------------------------------------*/
  2994.     /* Code Body                                                      */
  2995.     /*----------------------------------------------------------------*/
  2996.     DTGetRTCTime(alarmTime);
  2997.     memset(&incTime, 0, sizeof(MYTIME));
  2998.     incTime.nSec = ALM_FACTORY_RTC_TIME;
  2999.     IncrementTime(*alarmTime, incTime, alarmTime);
  3000.     *Freq = ALM_FREQ_ONCE;
  3001. }
  3004. /*****************************************************************************
  3005.  * FUNCTION
  3006.  *  FactoryExpiryHandler
  3007.  * DESCRIPTION
  3008.  *  Set facrtory mode alarm.
  3009.  * PARAMETERS
  3010.  *  Index           [IN]        
  3011.  *  period          [?]         
  3012.  *  power_on        [IN]        
  3013.  * RETURNS
  3014.  *  void
  3015.  *****************************************************************************/
  3016. U8 FactoryExpiryHandler(U8 Index, U16 *period, BOOL power_on)
  3017. {
  3018.     /*----------------------------------------------------------------*/
  3019.     /* Local Variables                                                */
  3020.     /*----------------------------------------------------------------*/
  3022.     /*----------------------------------------------------------------*/
  3023.     /* Code Body                                                      */
  3024.     /*----------------------------------------------------------------*/
  3025.     if (!power_on)
  3026.     {
  3027.         *period = ALM_DEFAULT_EXPIRY_PERIOD;
  3028.         AlmInitLCDModule();
  3029.         EntryAlmIndicationScreen();
  3030.         g_pwr_context.PowerOnMMIStatus = MMI_POWER_ON_IDLE; /* 0x80: Alarm idle screen */
  3031.         return ALM_HAS_IND;
  3032.     }
  3033.     *period = ALM_WITHOUD_EXPIRY_PERIOD;
  3034.     return ALM_HAS_NO_IND;
  3035. }
  3036. #endif /* (defined(MMI_ON_HARDWARE_P) && defined(__MMI_FACTORY_MODE__)) */ 
  3039. /*****************************************************************************
  3040.  * FUNCTION
  3041.  *  AlmATPowerReset
  3042.  * DESCRIPTION
  3043.  *  Set an reboot alarm for AT command
  3044.  * PARAMETERS
  3045.  *  power_off       [IN]        
  3046.  *  time            [IN]        
  3047.  * RETURNS
  3048.  *  void
  3049.  *****************************************************************************/
  3050. void AlmATPowerReset(U8 power_off, U8 time)
  3051. {
  3052. #ifdef __MMI_FACTORY_MODE__
  3053.     /*----------------------------------------------------------------*/
  3054.     /* Local Variables                                                */
  3055.     /*----------------------------------------------------------------*/
  3057.     /*----------------------------------------------------------------*/
  3058.     /* Code Body                                                      */
  3059.     /*----------------------------------------------------------------*/
  3060.     /* reuse the flag of factory alarm */
  3061.     gFactoryAlarm = 1;
  3063.     if (power_off)
  3064.     {
  3065.         g_alm_frm_cntx.ATPwrCycle = time;
  3066.     }
  3067.     else
  3068.     {
  3069.         g_alm_frm_cntx.ATPwrCycle = ALM_FACTORY_RTC_TIME;
  3070.     }
  3072.     g_alm_frm_cntx.IsATPwrOffAnimation = power_off;
  3074.     AlmSetAlarm(ALM_PWR_RESET);
  3075. #endif /* __MMI_FACTORY_MODE__ */ 
  3076. }
  3079. /*****************************************************************************
  3080.  * FUNCTION
  3081.  *  ResetExpiryTimeCB
  3082.  * DESCRIPTION
  3083.  *  Set facrtory mode alarm.
  3084.  * PARAMETERS
  3085.  *  index           [IN]        
  3086.  *  alarmTime       [?]         
  3087.  *  Freq            [?]         
  3088.  *  WeekDays        [?]         
  3089.  * RETURNS
  3090.  *  void
  3091.  *****************************************************************************/
  3092. void ResetExpiryTimeCB(U8 index, MYTIME *alarmTime, U8 *Freq, U8 *WeekDays, MYTIME *preReminder)
  3093. {
  3094.     /*----------------------------------------------------------------*/
  3095.     /* Local Variables                                                */
  3096.     /*----------------------------------------------------------------*/
  3097.     MYTIME incTime;
  3099.     /*----------------------------------------------------------------*/
  3100.     /* Code Body                                                      */
  3101.     /*----------------------------------------------------------------*/
  3102.     DTGetRTCTime(alarmTime);
  3103.     memset(&incTime, 0, sizeof(MYTIME));
  3104.     incTime.nSec = (g_alm_frm_cntx.ATPwrCycle % 60);
  3105.     incTime.nMin = (g_alm_frm_cntx.ATPwrCycle / 60);
  3106.     IncrementTime(*alarmTime, incTime, alarmTime);
  3107.     *Freq = ALM_FREQ_ONCE;
  3108. }
  3111. /*****************************************************************************
  3112.  * FUNCTION
  3113.  *  ResetExpiryHandler
  3114.  * DESCRIPTION
  3115.  *  Set facrtory mode alarm.
  3116.  * PARAMETERS
  3117.  *  index           [IN]        
  3118.  *  period          [?]         
  3119.  *  power_on        [IN]        
  3120.  * RETURNS
  3121.  *  void
  3122.  *****************************************************************************/
  3123. U8 ResetExpiryHandler(U8 index, U16 *period, BOOL power_on)
  3124. {
  3125.     /*----------------------------------------------------------------*/
  3126.     /* Local Variables                                                */
  3127.     /*----------------------------------------------------------------*/
  3129.     /*----------------------------------------------------------------*/
  3130.     /* Code Body                                                      */
  3131.     /*----------------------------------------------------------------*/
  3132.     if (!power_on)
  3133.     {
  3134.         AlmSendPowerOn();
  3135.     }
  3136.     *period = ALM_WITHOUD_EXPIRY_PERIOD;
  3137.     return ALM_HAS_NO_IND;
  3138. }
  3141. /*****************************************************************************
  3142.  * FUNCTION
  3143.  *  AlmIsPowerOffMode
  3144.  * DESCRIPTION
  3145.  *  Function to check if it's currently in power off mode
  3146.  * PARAMETERS
  3147.  *  void
  3148.  * RETURNS
  3149.  *  TRUE if alarm shall be executed as power off mode; otherwise, FALSE.
  3150.  *****************************************************************************/
  3151. BOOL AlmIsPowerOffMode(void)
  3152. {
  3153.     /*----------------------------------------------------------------*/
  3154.     /* Local Variables                                                */
  3155.     /*----------------------------------------------------------------*/
  3157.     /*----------------------------------------------------------------*/
  3158.     /* Code Body                                                      */
  3159.     /*----------------------------------------------------------------*/
  3160.     return ((g_pwr_context.PowerOnMode != POWER_ON_KEYPAD) && (g_pwr_context.PowerOnMode != POWER_ON_EXCEPTION));
  3161. }
  3164. /*****************************************************************************
  3165.  * FUNCTION
  3166.  *  AlmSetExpiryTimeCB
  3167.  * DESCRIPTION
  3168.  *  Set callback function of getting alarm expiry time by alarm type.
  3169.  * PARAMETERS
  3170.  *  AlmType                 [IN]        
  3171.  *  funcPtr                 [IN]        
  3172.  *  ExpiryTimeCBPtr(?)      [IN]        Function point
  3173.  *  U8(?)                   [IN]        Alarm type
  3174.  * RETURNS
  3175.  *  void
  3176.  *****************************************************************************/
  3177. void AlmSetExpiryTimeCB(U8 AlmType, ExpiryTimeCBPtr funcPtr)
  3178. {
  3179.     /*----------------------------------------------------------------*/
  3180.     /* Local Variables                                                */
  3181.     /*----------------------------------------------------------------*/
  3183.     /*----------------------------------------------------------------*/
  3184.     /* Code Body                                                      */
  3185.     /*----------------------------------------------------------------*/
  3186.     gAlmCBHandler[AlmType].expiryTimeCBPtr = funcPtr;
  3187. }
  3190. /*****************************************************************************
  3191.  * FUNCTION
  3192.  *  AlmSetExpiryHandlerCB
  3193.  * DESCRIPTION
  3194.  *  Set callback function of alarm expiry handler.
  3195.  * PARAMETERS
  3196.  *  AlmType                     [IN]        
  3197.  *  expiryHandler               [IN]        
  3198.  *  ExpiryHandlerCBPtr(?)       [IN]        Function point
  3199.  *  U8(?)                       [IN]        Alarm type
  3200.  * RETURNS
  3201.  *  void
  3202.  *****************************************************************************/
  3203. void AlmSetExpiryHandlerCB(U8 AlmType, ExpiryHandlerCBPtr expiryHandler)
  3204. {
  3205.     /*----------------------------------------------------------------*/
  3206.     /* Local Variables                                                */
  3207.     /*----------------------------------------------------------------*/
  3209.     /*----------------------------------------------------------------*/
  3210.     /* Code Body                                                      */
  3211.     /*----------------------------------------------------------------*/
  3212.     gAlmCBHandler[AlmType].expiryHandlerCBPtr = expiryHandler;
  3213. }
  3216. /*****************************************************************************
  3217.  * FUNCTION
  3218.  *  AlmSetInitHandlerCB
  3219.  * DESCRIPTION
  3220.  *  Set callback function of initing NVRAM and re-scheduling alarm queue.
  3221.  * PARAMETERS
  3222.  *  AlmType                         [IN]        
  3223.  *  initNvram                       [IN]        
  3224.  *  reInitQueue                     [IN]        
  3225.  *  ReInitAlarmQueueCBPtr(?)        [IN]        Function point
  3226.  *  InitAlarmNvramCBPtr(?)          [IN]        Function point
  3227.  *  U8(?)                           [IN]        Alarm type
  3228.  * RETURNS
  3229.  *  void
  3230.  *****************************************************************************/
  3231. void AlmSetInitHandlerCB(U8 AlmType, InitAlarmNvramCBPtr initNvram, ReInitAlarmQueueCBPtr reInitQueue)
  3232. {
  3233.     /*----------------------------------------------------------------*/
  3234.     /* Local Variables                                                */
  3235.     /*----------------------------------------------------------------*/
  3237.     /*----------------------------------------------------------------*/
  3238.     /* Code Body                                                      */
  3239.     /*----------------------------------------------------------------*/
  3240.     gAlmCBHandler[AlmType].initAlarmNvramCBPtr = initNvram;
  3241.     gAlmCBHandler[AlmType].reInitAlarmQueueCBPtr = reInitQueue;
  3242. }
  3245. /*****************************************************************************
  3246.  * FUNCTION
  3247.  *  AlmSetStopAlarmCB
  3248.  * DESCRIPTION
  3249.  *  Set callback function of stopping alarm when timeout
  3250.  * PARAMETERS
  3251.  *  AlmType                 [IN]        
  3252.  *  stopAlarm               [IN]        
  3253.  *  StopAlarmCBPtr(?)       [IN]        Function point
  3254.  *  U8(?)                   [IN]        Alarm type
  3255.  * RETURNS
  3256.  *  void
  3257.  *****************************************************************************/
  3258. void AlmSetStopAlarmCB(U8 AlmType, StopAlarmCBPtr stopAlarm)
  3259. {
  3260.     /*----------------------------------------------------------------*/
  3261.     /* Local Variables                                                */
  3262.     /*----------------------------------------------------------------*/
  3264.     /*----------------------------------------------------------------*/
  3265.     /* Code Body                                                      */
  3266.     /*----------------------------------------------------------------*/
  3267.     gAlmCBHandler[AlmType].stopAlarmCBPtr = stopAlarm;
  3268. }
  3271. /*****************************************************************************
  3272.  * FUNCTION
  3273.  *  mmi_alm_set_start_index
  3274.  * DESCRIPTION
  3275.  *  Set start index of alarm application
  3276.  * PARAMETERS
  3277.  *  AlmType         [IN]        
  3278.  *  startIndex      [IN]        
  3279.  *  U8(?)           [IN]        Start index
  3280.  * RETURNS
  3281.  *  void
  3282.  *****************************************************************************/
  3283. void mmi_alm_set_start_index(U8 AlmType, U8 startIndex)
  3284. {
  3285.     /*----------------------------------------------------------------*/
  3286.     /* Local Variables                                                */
  3287.     /*----------------------------------------------------------------*/
  3289.     /*----------------------------------------------------------------*/
  3290.     /* Code Body                                                      */
  3291.     /*----------------------------------------------------------------*/
  3292.     gAlmCBHandler[AlmType].alarmStartIndex = startIndex;
  3293. }
  3296. /*****************************************************************************
  3297.  * FUNCTION
  3298.  *  mmi_alm_get_index_from_queue
  3299.  * DESCRIPTION
  3300.  *  get alarm index from queue.
  3301.  * PARAMETERS
  3302.  *  num         [IN]        
  3303.  *  U8(?)       [IN]        Nth item of alarm queue
  3304.  * RETURNS
  3305.  *  U8 OUT   alarm index
  3306.  *****************************************************************************/
  3307. U8 mmi_alm_get_index_from_queue(U8 num)
  3308. {
  3309.     /*----------------------------------------------------------------*/
  3310.     /* Local Variables                                                */
  3311.     /*----------------------------------------------------------------*/
  3313.     /*----------------------------------------------------------------*/
  3314.     /* Code Body                                                      */
  3315.     /*----------------------------------------------------------------*/
  3316.     return gAlmQueue[num].Index;
  3317. }
  3320. /*****************************************************************************
  3321.  * FUNCTION
  3322.  *  mmi_alm_get_freq_order
  3323.  * DESCRIPTION
  3324.  *  Get frequency index of inline selection.
  3325.  * PARAMETERS
  3326.  *  freqNum     [IN]        
  3327.  *  freqSet     [IN]        
  3328.  *  freq        [IN]        
  3329.  * RETURNS
  3330.  *  void
  3331.  *****************************************************************************/
  3332. U8 mmi_alm_get_freq_order(U8 freqNum, const U8 *freqSet, U8 freq)
  3333. {
  3334.     /*----------------------------------------------------------------*/
  3335.     /* Local Variables                                                */
  3336.     /*----------------------------------------------------------------*/
  3337.     U8 i;
  3339.     /*----------------------------------------------------------------*/
  3340.     /* Code Body                                                      */
  3341.     /*----------------------------------------------------------------*/
  3342.     for (i = 0; i < freqNum; i++)
  3343.     {
  3344.         if (freqSet[i] == freq)
  3345.         {
  3346.             return i;
  3347.         }
  3348.     }
  3349. #ifdef MMI_ON_HARDWARE_P
  3350.     MMI_ASSERT(i < freqNum);
  3351. #endif 
  3353.     return (U8) 0;
  3354. }
  3357. /*****************************************************************************
  3358.  * FUNCTION
  3359.  *  mmi_alm_disable_pwroff
  3360.  * DESCRIPTION
  3361.  *  For applications executing during power off mode,
  3362.  *  and not allow alarm framework to shutdown the system when finishing alarm expiry.
  3363.  * PARAMETERS
  3364.  *  void
  3365.  * RETURNS
  3366.  *  void
  3367.  *****************************************************************************/
  3368. void mmi_alm_disable_pwroff(void)
  3369. {
  3370.     /*----------------------------------------------------------------*/
  3371.     /* Local Variables                                                */
  3372.     /*----------------------------------------------------------------*/
  3374.     /*----------------------------------------------------------------*/
  3375.     /* Code Body                                                      */
  3376.     /*----------------------------------------------------------------*/
  3377.     g_alm_frm_cntx.IsAppExecuting++;
  3378. }
  3381. /*****************************************************************************
  3382.  * FUNCTION
  3383.  *  mmi_alm_enable_pwroff
  3384.  * DESCRIPTION
  3385.  *  Reference of mmi_alm_disable_pwroff,
  3386.  *  need to be executed when stopping application.
  3387.  * PARAMETERS
  3388.  *  void
  3389.  * RETURNS
  3390.  *  void
  3391.  *****************************************************************************/
  3392. void mmi_alm_enable_pwroff(void)
  3393. {
  3394.     /*----------------------------------------------------------------*/
  3395.     /* Local Variables                                                */
  3396.     /*----------------------------------------------------------------*/
  3398.     /*----------------------------------------------------------------*/
  3399.     /* Code Body                                                      */
  3400.     /*----------------------------------------------------------------*/
  3401.     if (g_alm_frm_cntx.IsAppExecuting != 0)
  3402.     {
  3403.         g_alm_frm_cntx.IsAppExecuting--;
  3404.     }
  3405. }
  3406. #endif /* _MMI_ALARMFRAMEWORK_C */ // #ifndef _MMI_ALARMFRAMEWORK_C