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

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

MTK

开发平台：

C/C++

DateTime.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.  * DateTime.c
  41.  *
  42.  * Project:
  43.  * --------
  44.  *   MAUI
  45.  *
  46.  * Description:
  47.  * ------------
  48.  * This file implements date/time related utilities for other applications
  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.  *------------------------------------------------------------------------------
  149.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  150.  *============================================================================
  151.  ****************************************************************************/
  152. /*****************************************************************************
  153. *  Copyright Statement:
  154. *  --------------------
  155. *  This software is protected by Copyright and the information contained
  156. *  herein is confidential. The software may not be copied and the information
  157. *  contained herein may not be used or disclosed except with the written
  158. *  permission of MediaTek Inc. (C) 2004
  159. *
  160. *****************************************************************************/
  162. /*****************************************************************************
  163.  *
  164.  * Filename:
  165.  * ---------
  166.  * DateTime.c
  167.  *
  168.  * Project:
  169.  * --------
  170.  *   MAUI
  171.  *
  172.  * Description:
  173.  * ------------
  174.  *   This file implements date/time related utilities for other applications
  175.  *
  176.  * Author:
  177.  * -------
  178.  * -------
  179.  *
  180.  *============================================================================
  181.  *             HISTORY
  182.  * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  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.  *
  228.  * removed!
  229.  * removed!
  230.  * removed!
  231.  *
  232.  * removed!
  233.  * removed!
  234.  * removed!
  235.  *
  236.  * removed!
  237.  * removed!
  238.  * removed!
  239.  *
  240.  * removed!
  241.  * removed!
  242.  * removed!
  243.  *
  244.  * removed!
  245.  * removed!
  246.  * removed!
  247.  *
  248.  * removed!
  249.  * removed!
  250.  * removed!
  251.  *
  252.  * removed!
  253.  * removed!
  254.  * removed!
  255.  *
  256.  * removed!
  257.  * removed!
  258.  * removed!
  259.  *
  260.  * removed!
  261.  * removed!
  262.  * removed!
  263.  *
  264.  * removed!
  265.  * removed!
  266.  * removed!
  267.  *
  268.  * removed!
  269.  * removed!
  270.  * removed!
  271.  *
  272.  * removed!
  273.  * removed!
  274.  * removed!
  275.  * removed!
  276.  * removed!
  277.  * removed!
  278.  * removed!
  279.  * removed!
  280.  * removed!
  281.  * removed!
  282.  * removed!
  283.  * removed!
  284.  * removed!
  285.  * removed!
  286.  * removed!
  287.  * removed!
  288.  * removed!
  289.  * removed!
  290.  * removed!
  291.  * removed!
  292.  *
  293.  *------------------------------------------------------------------------------
  294.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  295.  *============================================================================
  296.  ****************************************************************************/
  297. /**
  298.  * Copyright Notice
  299.  * ?2002 - 2003, Pixtel Communications, Inc., 1489 43rd Ave. W.,
  300.  * Vancouver, B.C. V6M 4K8 Canada. All Rights Reserved.
  301.  *  (It is illegal to remove this copyright notice from this software or any
  302.  *  portion of it)
  303.  */
  304. /**************************************************************
  306.    FILENAME : DateTime.c
  308.    PURPOSE     : Utility functions to enable date and time display on idle screen
  310.    REMARKS     : nil
  312.    AUTHOR      : Neeraj Sharma, Vijay Vaidya
  314.    DATE     : Aug' 28, 2002
  316. **************************************************************/
  318. #ifndef _MMI_DATETIME_C
  319. #define _MMI_DATETIME_C
  320. #include "MMI_features.h"
  322. /*  Include: MMI header file */
  323. #include "Stdafx.h"
  324. #include "PixtelDataTypes.h"
  325. #include "DebugInitDef.h"
  326. #include "DateTimeType.h"
  327. #include "EventsGprot.h"
  328. #include "DateTimeGprot.h"
  329. #include "L4Dr.h"
  330. #include <time.h>
  331. #include "TimerEvents.h"
  332. #ifndef MMI_ON_WIN32
  333. #include "rtc_sw.h"
  334. #endif 
  336. #include "NVRAMType.h"
  337. #include "NVRAMEnum.h"
  338. #include "NVRAMProt.h"
  339. #include "SimDetectionGexdcl.h"
  340. #include "SimDetectionGprot.h"
  341. #include "AlarmFrameworkProt.h"
  342. #include "SettingStructs.h"
  343. #include "ProtocolEvents.h"
  345. #ifdef __MMI_LCD_PARTIAL_ON__
  346. #include "IdleAppProt.h"
  347. #endif 
  349. /*  Include: PS header file */
  351. /* 
  352.  * Define
  353.  */
  354. #define  DT_UTC_BASE_YEAR  1970
  355. #define  DT_MONTH_PER_YEAR    12
  356. #define  DT_DAY_PER_YEAR         365
  357. #define  DT_SEC_PER_DAY    86400
  358. #define  DT_SEC_PER_HOUR      3600
  359. #define  DT_SEC_PER_MIN    60
  360. #define MMI_DT_YEAR_BOUNDARY     30
  361. /* 
  362.  * Typedef 
  363.  */
  365. /* 
  366.  * Local Variable
  367.  */
  368. #ifdef MMI_ON_WIN32
  369. const U8 gDaysInMonth[NUM_MONTHS] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
  370. #define DT_DAYS_OF_WEEK 7
  371. #endif 
  373. #ifdef MMI_ON_WIN32
  374. MYTIME MyTime = {0, 1, 1, 1, 1, 1, 0};  /* Variable used by Setting Application */
  375. S8 DateTimeStrings[2][30];              /* amitm5 to be removed as told by manju */
  376. static S8 NameOfMonth[12][4] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
  377. static S8 NameOfday[7][4] = { "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun" };
  378. #endif /* MMI_ON_WIN32 */ 
  380. /* 
  381.  * Local Function
  382.  */
  383. static void DTResetTime(void);
  385. /* 
  386.  * Global Variable
  387.  */
  388. /* extern U8 idleScreenFirst; */
  389. U8 CMDateTimeRequest = 0;
  390. U8 CMCallCount = 0;
  391. U8 CMCallBackCount = 0;
  392. extern U8 g_dst;
  393. DateTimeFuncPtr CMDateTimeCallBack[MAX_CM_CALLS];
  395. #ifndef __MTK_TARGET__
  396. extern MYTIME MyTime;
  397. #endif 
  398. #ifndef MMI_ON_WIN32
  399. extern rtc_format_struct gclockData;
  400. #endif 
  402. #if !defined(__MMI_GPIO_DISABLE_SLEEP_MODE__)
  403. extern BOOL gIsInSleepMode;
  404. #endif 
  405. /* 
  406.  * Global Function
  407.  */
  408. extern FLOAT GetTimeZone(U8);
  409. extern U8 PhnsetGetHomeCity(void);
  411. #ifdef MMI_ON_WIN32
  413. extern kal_uint8 g_dst;
  414. /*****************************************************************************
  415.  * FUNCTION
  416.  *  applib_dt_is_dst_enabled
  417.  * DESCRIPTION
  418.  *  Tp check if daylight saving time is enabled
  419.  * PARAMETERS
  420.  *  void
  421.  *  t  time to be computed(?)
  422.  * RETURNS
  423.  *  TURE if enabled; otherwise, false
  424.  *****************************************************************************/
  425. kal_bool applib_dt_is_dst_enabled(void)
  426. {
  427.     /*----------------------------------------------------------------*/
  428.     /* Local Variables                                                */
  429.     /*----------------------------------------------------------------*/
  431.     /*----------------------------------------------------------------*/
  432.     /* Code Body                                                      */
  433.     /*----------------------------------------------------------------*/
  434.     return (kal_bool) g_dst;
  435. }
  436. /*****************************************************************************
  437.  * FUNCTION
  438.  *  MyMonth
  439.  * DESCRIPTION
  440.  *  Fucntion to update year and month, this function is used in PC simulator only.
  441.  * PARAMETERS
  442.  *  void
  443.  * RETURNS
  444.  *  void
  445.  *****************************************************************************/
  446. void MyMonth()
  447. {
  448.     /*----------------------------------------------------------------*/
  449.     /* Local Variables                                                */
  450.     /*----------------------------------------------------------------*/
  452.     /*----------------------------------------------------------------*/
  453.     /* Code Body                                                      */
  454.     /*----------------------------------------------------------------*/
  455.     if (MyTime.nMonth == 12)
  456.     {
  457.         MyTime.nMonth = 1;
  458.         MyTime.nYear++;
  459.     }
  460.     else
  461.     {
  462.         MyTime.nMonth++;
  463.     }
  464. }
  467. /*****************************************************************************
  468.  * FUNCTION
  469.  *  DateTimerProc
  470.  * DESCRIPTION
  471.  *  Fucntion to update and display date and time. This function is used in PC simulator only.
  472.  * PARAMETERS
  473.  *  void
  474.  * RETURNS
  475.  *  void
  476.  *****************************************************************************/
  477. void DateTimerProc(void)
  478. {
  479.     /*----------------------------------------------------------------*/
  480.     /* Local Variables                                                */
  481.     /*----------------------------------------------------------------*/
  482.     //#ifdef MMI_ON_HARDWARE_P
  483.     //      L4GetClockTime();
  484.     //#else
  485.     S32 CompareDay = 28;
  486.     S16 isLeapYear = 0;
  487.     U8 nDateChanged = 0x0;
  488.     U8 update_flag = 0;
  490. /********************************************************
  491. Patch for the demo:: Min_Change_flag has been added to support low power mode.
  492. (May be we should have timer for 60 seconds).
  493. **********************************************************/
  494.     S32 Min_Change_flag = 0;
  496.     /*----------------------------------------------------------------*/
  497.     /* Code Body                                                      */
  498.     /*----------------------------------------------------------------*/
  499.     StartTimer(TIMER_REAL_TIME_CLOCK, 1000, DateTimerProc); /* 072605 Calvin added */
  501.     if (MyTime.nSec == 59)
  502.     {
  503.         MyTime.nSec = 0;
  504.         Min_Change_flag = 1;
  505.         update_flag = 1;
  506.         if (MyTime.nMin == 59)
  507.         {
  508.             MyTime.nMin = 0;
  509.             if (MyTime.nHour == 23)
  510.             {
  511.                 MyTime.nHour = 0;
  512.                 nDateChanged = 0x1;
  513.                 update_flag = 1;
  514.                 if (MyTime.DayIndex == 6)
  515.                 {
  516.                     MyTime.DayIndex = 0;
  517.                 }
  518.                 else
  519.                 {
  520.                     MyTime.DayIndex++;
  521.                 }
  522.                 switch (MyTime.nMonth)
  523.                 {
  524.                     case 1:
  525.                     case 3:
  526.                     case 5:
  527.                     case 7:
  528.                     case 8:
  529.                     case 10:
  530.                     case 12:
  531.                         if (MyTime.nDay == 31)
  532.                         {
  533.                             MyTime.nDay = 1;
  534.                             MyMonth();
  535.                         }
  536.                         else
  537.                         {
  538.                             MyTime.nDay++;
  539.                         }
  540.                         break;
  541.                     case 4:
  542.                     case 6:
  543.                     case 9:
  544.                     case 11:
  545.                         if (MyTime.nDay == 30)
  546.                         {
  547.                             MyTime.nDay = 1;
  548.                             MyMonth();
  549.                         }
  550.                         else
  551.                         {
  552.                             MyTime.nDay++;
  553.                         }
  554.                         break;
  555.                     case 2: /* Check for leap year */
  556.                         if (((MyTime.nYear % 100) == 0) && ((MyTime.nYear % 400) == 0))
  557.                         {
  558.                             isLeapYear = 1;
  559.                         }
  560.                         else if ((MyTime.nYear % 4) == 0)
  561.                         {
  562.                             isLeapYear = 1;
  563.                         }
  564.                         else    /* Not a leap year */
  565.                         {
  566.                             isLeapYear = 0;
  567.                         }
  568.                         if (isLeapYear)
  569.                         {
  570.                             CompareDay = 29;
  571.                         }
  572.                         else
  573.                         {
  574.                             CompareDay = 28;
  575.                         }
  576.                         /* (isLeapYear) ? CompareDay = 29 : CompareDay = 28; */
  577.                         if (MyTime.nDay == CompareDay)
  578.                         {
  579.                             MyTime.nDay = 1;
  580.                             MyMonth();
  581.                         }
  582.                         else
  583.                         {
  584.                             MyTime.nDay++;
  585.                         }
  586.                         break;
  587.                     default:
  588.                         break;
  589.                 }
  590.                 //Right now only for time...need to expand to accommodate year and month
  591.                 //update
  592.             }
  593.             else
  594.             {
  595.                 MyTime.nHour++;
  596.             }
  597.         }
  598.         else
  599.         {
  600.             MyTime.nMin++;
  601.         }
  602.     }
  603.     else
  604.     {
  605.         MyTime.nSec++;
  606.     }
  607.     //sprintf(DateTimeStrings[0],"%s %02d %s %d",NameOfday[MyTime.DayIndex],MyTime.nDay,NameOfMonth[MyTime.nMonth-1],MyTime.nYear);
  608.     //sprintf(DateTimeStrings[1],"%02d:%02d:%02d",MyTime.nHour,MyTime.nMin,MyTime.nSec); 
  609.     if (update_flag)
  610.     {   /* Lisen0522 */
  611.         update_mainlcd_dt_display();
  612.         update_sublcd_dt_display();
  613.     }
  614.     /*  */
  615. }
  618. /*****************************************************************************
  619.  * FUNCTION
  620.  *  InitTime
  621.  * DESCRIPTION
  622.  *  Function to initialize golbal variables and local date and time.
  623.  * PARAMETERS
  624.  *  void
  625.  * RETURNS
  626.  *  void
  627.  *****************************************************************************/
  628. void InitTime(void)
  629. {
  630. #ifdef __MTK_TARGET__
  631.     /*----------------------------------------------------------------*/
  632.     /* Local Variables                                                */
  633.     /*----------------------------------------------------------------*/
  635.     /*----------------------------------------------------------------*/
  636.     /* Code Body                                                      */
  637.     /*----------------------------------------------------------------*/
  638. #ifdef __DAILY_WALLPAPER__
  639.     memset(&gWallpaperChangeDate, 0xFF, sizeof(gWallpaperChangeDate));  /* Robin 1226 */
  640. #endif 
  641. #elif MMI_ON_WIN32
  642.     SYSTEMTIME systime;
  643.     time_t ltime;
  644.     S8 MyDay[4];
  645.     S16 i;
  647.     GetLocalTime(&systime);
  648.     time(&ltime);
  649.     strncpy(MyDay, ctime(&ltime), 3);
  650.     /* stack corruption fixed Kuldeep for Network Simulator 2.0 */
  651.     MyDay[3] = '';
  652.     /* changes done by Kuldeep */
  654.     for (i = 0; i < 7; i++)
  655.     {
  656.         if (strncmp(MyDay, NameOfday[i], 3) == 0)
  657.         {
  658.             break;
  659.         }
  660.     }
  662.     MyTime.nYear = systime.wYear;
  663.     MyTime.nMonth = (U8) systime.wMonth;
  664.     MyTime.nDay = (U8) systime.wDay;
  665.     MyTime.nHour = (U8) systime.wHour;
  666.     MyTime.nMin = (U8) systime.wMinute;
  667.     MyTime.nSec = (U8) systime.wSecond;
  668.     MyTime.DayIndex = (U8) i;
  670.     sprintf(
  671.         DateTimeStrings[0],
  672.         "%s  %02d %s  %d",
  673.         NameOfday[MyTime.DayIndex],
  674.         MyTime.nDay,
  675.         NameOfMonth[MyTime.nMonth - 1],
  676.         MyTime.nYear);
  677.     //sprintf(DateTimeStrings[1],"%02d::%02d::%02d",MyTime.nHour,MyTime.nMin,MyTime.nSec);
  678.     //sprintf(DateTimeStrings[1],"%02d:%02d",MyTime.nHour,MyTime.nMin);
  679.     StartTimer(TIMER_REAL_TIME_CLOCK, 1000, DateTimerProc);
  680. #else 
  681.     MyTime.nYear += DT_MIN_YEAR;
  682.     StartTimer(TIMER_REAL_TIME_CLOCK, 1000, DateTimerProc);
  683. #endif 
  685. }
  688. /*****************************************************************************
  689.  * FUNCTION
  690.  *  GetDateTime
  691.  * DESCRIPTION
  692.  *  Function to get the current date and time.
  693.  * PARAMETERS
  694.  *  t       [IN/OUT]        Variable to store the result.
  695.  * RETURNS
  696.  *  void
  697.  *****************************************************************************/
  698. void GetDateTime(MYTIME *t)
  699. {
  700. #ifdef __MTK_TARGET__
  701.     /*----------------------------------------------------------------*/
  702.     /* Local Variables                                                */
  703.     /*----------------------------------------------------------------*/
  705.     /*----------------------------------------------------------------*/
  706.     /* Code Body                                                      */
  707.     /*----------------------------------------------------------------*/
  708.     t->nSec = gclockData.rtc_sec;
  709.     t->nMin = gclockData.rtc_min;
  710.     t->nHour = gclockData.rtc_hour;
  711.     t->nDay = gclockData.rtc_day;
  712.     t->nMonth = gclockData.rtc_mon;
  713.     t->DayIndex = gclockData.rtc_wday;
  714.     t->nYear = YEARFORMATE + gclockData.rtc_year;
  715. #else /* __MTK_TARGET__ */ 
  716.     t->DayIndex = MyTime.DayIndex;
  717.     t->nDay = MyTime.nDay;
  718.     t->nHour = MyTime.nHour;
  719.     t->nMin = MyTime.nMin;
  720.     t->nSec = MyTime.nSec;
  721.     t->nMonth = MyTime.nMonth;
  722.     t->nYear = MyTime.nYear;
  723. #endif /* __MTK_TARGET__ */ 
  724.     t->DayIndex = DOW(t->nYear, t->nMonth, t->nDay);
  725. }
  728. /*****************************************************************************
  729.  * FUNCTION
  730.  *  DOW
  731.  * DESCRIPTION
  732.  *  Function to compute current day of week.
  733.  * PARAMETERS
  734.  *  y       [IN]        Year of the date to be computed. (example, 2004)
  735.  *  m       [IN]        Month of the date to be computed
  736.  *  d       [IN]        Day of the date to be computed
  737.  * RETURNS
  738.  *  U8 index of day of week
  739.  *****************************************************************************/
  740. U8 DOW(U16 y, U8 m, U8 d)
  741. {
  742.     /*----------------------------------------------------------------*/
  743.     /* Local Variables                                                */
  744.     /*----------------------------------------------------------------*/
  746.     /*----------------------------------------------------------------*/
  747.     /* Code Body                                                      */
  748.     /*----------------------------------------------------------------*/
  749.     if (m < 3)
  750.     {
  751.         m += 13;
  752.         y--;
  753.     }
  754.     else
  755.     {
  756.         m++;
  757.     }
  759.     return (d + 26 * m / 10 + y + y / 4 - y / 100 + y / 400 + 6) % 7;
  760. }
  763. /*****************************************************************************
  764.  * FUNCTION
  765.  *  IsLeapYear
  766.  * DOW
  767.  * DESCRIPTION
  768.  *  Function to find out if given year is a leap year
  769.  * PARAMETERS
  770.  *  year        [IN]        
  771.  *  y(?)        [IN]        Year of the date to be computed  (example, 2004)(?)
  772.  * RETURNS
  773.  *  1 if the year is leap; otherwise 0.
  774.  *****************************************************************************/
  775. U16 IsLeapYear(U16 year)
  776. {
  777.     /*----------------------------------------------------------------*/
  778.     /* Local Variables                                                */
  779.     /*----------------------------------------------------------------*/
  781.     /*----------------------------------------------------------------*/
  782.     /* Code Body                                                      */
  783.     /*----------------------------------------------------------------*/
  784.     if ((year % 400) == 0)
  785.     {
  786.         return 1;
  787.     }
  788.     else if ((year % 100) == 0)
  789.     {
  790.         return 0;
  791.     }
  792.     else if ((year % 4) == 0)
  793.     {
  794.         return 1;
  795.     }
  796.     else
  797.     {
  798.         return 0;
  799.     }
  800. }
  803. /*****************************************************************************
  804.  * FUNCTION
  805.  *  GetTimeDifference
  806.  * DESCRIPTION
  807.  *  Function to calculate the difference between 2 times.
  808.  * PARAMETERS
  809.  *  t1          [IN]            The target time
  810.  *  t2          [IN]            The base time  (t1 shall be greater than t2)
  811.  *  result      [IN/OUT]        Result of t1-t2
  812.  * RETURNS
  813.  *  NULL if t1 < t2; otherwise, return result
  814.  *****************************************************************************/
  815. MYTIME *GetTimeDifference(MYTIME *t1, MYTIME *t2, MYTIME *result)
  816. {
  817.     /*----------------------------------------------------------------*/
  818.     /* Local Variables                                                */
  819.     /*----------------------------------------------------------------*/
  821.     /*----------------------------------------------------------------*/
  822.     /* Code Body                                                      */
  823.     /*----------------------------------------------------------------*/
  824.     /* Validate year ..no need of validating for month .. */
  825.     /* /Handled NULL  changes by Kuldeep for Network Simulator 2.0 */
  826.     if (NULL == t2)
  827.     {
  828.         return NULL;
  829.     }
  830.     /* /Handled NULL  changes by Kuldeep */
  831.     if (t1->nYear < t2->nYear)
  832.     {
  833.         return NULL;
  834.     }
  835.     else
  836.     {
  837.         DecrementTime2(*t1, *t2, result);
  838.         return result;
  839.     }
  840. }
  843. /*****************************************************************************
  844.  * FUNCTION
  845.  *  FindMaxTime
  846.  * DESCRIPTION
  847.  *  Function to find the larger one between two times
  848.  * PARAMETERS
  849.  *  t1      [IN]        The first time to be compared.
  850.  *  t2      [IN]        The second time to be compared.
  851.  * RETURNS
  852.  *  0 if t1 < t2; otherwise 1.
  853.  *****************************************************************************/
  854. U16 FindMaxTime(MYTIME *t1, MYTIME *t2)
  855. {
  856.     /*----------------------------------------------------------------*/
  857.     /* Local Variables                                                */
  858.     /*----------------------------------------------------------------*/
  860.     /*----------------------------------------------------------------*/
  861.     /* Code Body                                                      */
  862.     /*----------------------------------------------------------------*/
  863.     if (t1->nYear == t2->nYear)
  864.     {
  865.         if (t1->nMonth == t2->nMonth)
  866.         {
  867.             if (t1->nDay == t2->nDay)
  868.             {
  869.                 if (t1->nHour == t2->nHour)
  870.                 {
  871.                     if (t1->nMin == t2->nMin)
  872.                     {
  873.                         if (t1->nSec >= t2->nSec)
  874.                         {
  875.                             return 1;
  876.                         }
  877.                         else
  878.                         {
  879.                             return 0;
  880.                         }
  881.                     }
  882.                     else if (t1->nMin > t2->nMin)
  883.                     {
  884.                         return 1;
  885.                     }
  886.                     else
  887.                     {
  888.                         return 0;
  889.                     }
  890.                 }
  891.                 else if (t1->nHour > t2->nHour)
  892.                 {
  893.                     return 1;
  894.                 }
  895.                 else
  896.                 {
  897.                     return 0;
  898.                 }
  899.             }
  900.             else if (t1->nDay > t2->nDay)
  901.             {
  902.                 return 1;
  903.             }
  904.             else
  905.             {
  906.                 return 0;
  907.             }
  908.         }
  909.         else if (t1->nMonth > t2->nMonth)
  910.         {
  911.             return 1;
  912.         }
  913.         else
  914.         {
  915.             return 0;
  916.         }
  917.     }
  918.     else if (t1->nYear > t2->nYear)
  919.     {
  920.         return 1;
  921.     }
  922.     else
  923.     {
  924.         return 0;
  925.     }
  926. }
  929. /*****************************************************************************
  930.  * FUNCTION
  931.  *  DecrementTime2
  932.  * DESCRIPTION
  933.  *  Decrease a reference time by some time.
  934.  *  The difference between DecrementTime is the result may not be a "time"
  935.  *  Because it's just to get the "difference", the time may be 1 month, 0 day, 12 minutes
  936.  * PARAMETERS
  937.  *  timeToDecrement     [IN]            Time to be decreased
  938.  *  decrement           [IN]            Time to decrease
  939.  *  Result              [IN/OUT]        Result of compuatation
  940.  * RETURNS
  941.  *  void
  942.  *****************************************************************************/
  943. void DecrementTime2(MYTIME timeToDecrement, MYTIME decrement, MYTIME *Result)
  944. {
  945.     /*----------------------------------------------------------------*/
  946.     /* Local Variables                                                */
  947.     /*----------------------------------------------------------------*/
  949.     /*----------------------------------------------------------------*/
  950.     /* Code Body                                                      */
  951.     /*----------------------------------------------------------------*/
  952.     if (decrement.nSec != 0)
  953.     {
  954.         if (timeToDecrement.nSec >= decrement.nSec)
  955.         {
  956.             Result->nSec = timeToDecrement.nSec - decrement.nSec;
  957.         }
  958.         else
  959.         {
  960.             Result->nSec = NUM_MIN_HR + timeToDecrement.nSec - decrement.nSec;
  961.             decrement.nMin++;
  962.         }
  963.     }
  964.     else
  965.     {
  966.         Result->nSec = timeToDecrement.nSec;
  967.     }
  969.     if (decrement.nMin != 0)
  970.     {
  971.         if (timeToDecrement.nMin >= decrement.nMin)
  972.         {
  973.             Result->nMin = timeToDecrement.nMin - decrement.nMin;
  974.         }
  975.         else
  976.         {
  977.             Result->nMin = NUM_MIN_HR + timeToDecrement.nMin - decrement.nMin;
  978.             decrement.nHour++;
  979.         }
  980.     }
  981.     else
  982.     {
  983.         Result->nMin = timeToDecrement.nMin;
  984.     }
  986.     if (decrement.nHour != 0)
  987.     {
  988.         if (timeToDecrement.nHour >= decrement.nHour)
  989.         {
  990.             Result->nHour = timeToDecrement.nHour - decrement.nHour;
  991.         }
  992.         else
  993.         {
  994.             Result->nHour = NUM_HRS_DAY + timeToDecrement.nHour - decrement.nHour;
  995.             decrement.nDay++;
  996.         }
  997.     }
  998.     else
  999.     {
  1000.         Result->nHour = timeToDecrement.nHour;
  1001.     }
  1003.     if (decrement.nDay != 0)
  1004.     {
  1005.         if (timeToDecrement.nDay >= decrement.nDay)
  1006.         {
  1007.             Result->nDay = timeToDecrement.nDay - decrement.nDay;
  1008.         }
  1009.         else
  1010.         {
  1011.             U8 tmp_last_day;
  1013.             decrement.nMonth++;
  1014.             if (timeToDecrement.nMonth != JAN)
  1015.             {
  1016.                 tmp_last_day = LastDayOfMonth((U8) (timeToDecrement.nMonth - 1), timeToDecrement.nYear);
  1017.             }
  1018.             else
  1019.             {
  1020.                 tmp_last_day = 31;
  1021.             }
  1023.             if (tmp_last_day < (tmp_last_day + timeToDecrement.nDay - decrement.nDay))
  1024.             {
  1025.                 if (DEC == timeToDecrement.nMonth)
  1026.                 {
  1027.                     tmp_last_day += 31;
  1028.                 }
  1029.                 else
  1030.                 {
  1031.                     tmp_last_day += LastDayOfMonth((U8) (timeToDecrement.nMonth), timeToDecrement.nYear);
  1032.                 }
  1033.                 decrement.nMonth++;
  1034.             }
  1036.             Result->nDay = tmp_last_day + timeToDecrement.nDay - decrement.nDay;
  1037.         }
  1038.     }
  1039.     else
  1040.     {
  1041.         Result->nDay = timeToDecrement.nDay;
  1042.     }
  1044.     if (decrement.nMonth != 0)
  1045.     {
  1046.         if (timeToDecrement.nMonth >= decrement.nMonth)
  1047.         {
  1048.             Result->nMonth = timeToDecrement.nMonth - decrement.nMonth;
  1049.         }
  1050.         else
  1051.         {
  1052.             Result->nMonth = NUM_MONTHS + timeToDecrement.nMonth - decrement.nMonth;
  1053.             decrement.nYear++;
  1054.         }
  1055.     }
  1056.     else
  1057.     {
  1058.         Result->nMonth = timeToDecrement.nMonth;
  1059.     }
  1061.     Result->nYear = timeToDecrement.nYear - decrement.nYear;
  1063.     Result->DayIndex = DOW(Result->nYear, Result->nMonth, Result->nDay);
  1064. }
  1067. /*****************************************************************************
  1068.  * FUNCTION
  1069.  *  DecrementTime
  1070.  * DESCRIPTION
  1071.  *  Decrease a reference time by some time
  1072.  * PARAMETERS
  1073.  *  timeToDecrement     [IN]            Time to be decreased
  1074.  *  decrement           [IN]            Time to decrease
  1075.  *  Result              [IN/OUT]        Result of compuatation
  1076.  * RETURNS
  1077.  *  void
  1078.  *****************************************************************************/
  1079. void DecrementTime(MYTIME timeToDecrement, MYTIME decrement, MYTIME *Result)
  1080. {
  1081.     /*----------------------------------------------------------------*/
  1082.     /* Local Variables                                                */
  1083.     /*----------------------------------------------------------------*/
  1085.     /*----------------------------------------------------------------*/
  1086.     /* Code Body                                                      */
  1087.     /*----------------------------------------------------------------*/
  1088.     if (decrement.nSec != 0)
  1089.     {
  1090.         if (timeToDecrement.nSec >= decrement.nSec)
  1091.         {
  1092.             Result->nSec = timeToDecrement.nSec - decrement.nSec;
  1093.         }
  1094.         else
  1095.         {
  1096.             Result->nSec = NUM_MIN_HR + timeToDecrement.nSec - decrement.nSec;
  1097.             decrement.nMin++;
  1098.         }
  1099.     }
  1100.     else
  1101.     {
  1102.         Result->nSec = timeToDecrement.nSec;
  1103.     }
  1105.     if (decrement.nMin != 0)
  1106.     {
  1107.         if (timeToDecrement.nMin >= decrement.nMin)
  1108.         {
  1109.             Result->nMin = timeToDecrement.nMin - decrement.nMin;
  1110.         }
  1111.         else
  1112.         {
  1113.             Result->nMin = NUM_MIN_HR + timeToDecrement.nMin - decrement.nMin;
  1114.             decrement.nHour++;
  1115.         }
  1116.     }
  1117.     else
  1118.     {
  1119.         Result->nMin = timeToDecrement.nMin;
  1120.     }
  1122.     if (decrement.nHour != 0)
  1123.     {
  1124.         if (timeToDecrement.nHour >= decrement.nHour)
  1125.         {
  1126.             Result->nHour = timeToDecrement.nHour - decrement.nHour;
  1127.         }
  1128.         else
  1129.         {
  1130.             Result->nHour = NUM_HRS_DAY + timeToDecrement.nHour - decrement.nHour;
  1131.             decrement.nDay++;
  1132.         }
  1133.     }
  1134.     else
  1135.     {
  1136.         Result->nHour = timeToDecrement.nHour;
  1137.     }
  1139.     if (decrement.nDay != 0)
  1140.     {
  1141.         if (timeToDecrement.nDay > decrement.nDay)
  1142.         {
  1143.             Result->nDay = timeToDecrement.nDay - decrement.nDay;
  1144.         }
  1145.         else
  1146.         {
  1147.             decrement.nMonth++;
  1148.             if (timeToDecrement.nMonth != JAN)
  1149.             {
  1150.                 Result->nDay = LastDayOfMonth(
  1151.                                 (U8) (timeToDecrement.nMonth - 1),
  1152.                                 timeToDecrement.nYear) + timeToDecrement.nDay - decrement.nDay;
  1153.             }
  1154.             else
  1155.             {
  1156.                 Result->nDay = 31 + timeToDecrement.nDay - decrement.nDay;
  1157.             }
  1158.         }
  1159.     }
  1160.     else
  1161.     {
  1162.         Result->nDay = timeToDecrement.nDay;
  1163.     }
  1165.     if (decrement.nMonth != 0)
  1166.     {
  1167.         if (timeToDecrement.nMonth > decrement.nMonth)
  1168.         {
  1169.             Result->nMonth = timeToDecrement.nMonth - decrement.nMonth;
  1170.         }
  1171.         else
  1172.         {
  1173.             Result->nMonth = NUM_MONTHS + timeToDecrement.nMonth - decrement.nMonth;
  1174.             decrement.nYear++;
  1175.         }
  1176.     }
  1177.     else
  1178.     {
  1179.         Result->nMonth = timeToDecrement.nMonth;
  1180.     }
  1182.     Result->nYear = timeToDecrement.nYear - decrement.nYear;
  1184.     Result->DayIndex = DOW(Result->nYear, Result->nMonth, Result->nDay);
  1186. }
  1189. /*****************************************************************************
  1190.  * FUNCTION
  1191.  *  DTGetRTCTime
  1192.  * DESCRIPTION
  1193.  *  Get current RTC time of system.
  1194.  * PARAMETERS
  1195.  *  t       [IN/OUT]        Variable to store current time.
  1196.  * RETURNS
  1197.  *  void
  1198.  *****************************************************************************/
  1199. void DTGetRTCTime(MYTIME *t)
  1200. {
  1201. #ifdef __MTK_TARGET__
  1202.     /*----------------------------------------------------------------*/
  1203.     /* Local Variables                                                */
  1204.     /*----------------------------------------------------------------*/
  1205.     t_rtc rtc_time;
  1207.     /*----------------------------------------------------------------*/
  1208.     /* Code Body                                                      */
  1209.     /*----------------------------------------------------------------*/
  1210.     RTC_GetTime(&rtc_time);
  1212.     t->nYear = rtc_time.rtc_year + YEARFORMATE;
  1213.     t->nMonth = rtc_time.rtc_mon;
  1214.     t->nDay = rtc_time.rtc_day;
  1215.     t->nHour = rtc_time.rtc_hour;
  1216.     t->nMin = rtc_time.rtc_min;
  1217.     t->nSec = rtc_time.rtc_sec;
  1218.     t->DayIndex = DOW(t->nYear, t->nMonth, t->nDay);
  1219. #else /* __MTK_TARGET__ */ 
  1220.     GetDateTime(&(*t));
  1221. #endif /* __MTK_TARGET__ */ 
  1222. }
  1225. /*****************************************************************************
  1226.  * FUNCTION
  1227.  *  CompareTime
  1228.  * DESCRIPTION
  1229.  *  Compare the equality between 2 times.
  1230.  * PARAMETERS
  1231.  *  referenceTime       [IN]        Time to be compare in right-hand side
  1232.  *  compareTime         [IN]        Time to be compare in left-hand side
  1233.  *  diff                [IN]        Not yet used
  1234.  * RETURNS
  1235.  *  TIME_LESS      if referenceTime < compareTime
  1236.  *  TIME_EQUAL     if referenceTime = compareTime
  1237.  *  TIME_GREATER   if referenceTime > compareTime
  1238.  *****************************************************************************/
  1239. TIME_EQUALITY CompareTime(MYTIME referenceTime, MYTIME compareTime, MYTIME *diff)
  1240. {
  1241.     /*----------------------------------------------------------------*/
  1242.     /* Local Variables                                                */
  1243.     /*----------------------------------------------------------------*/
  1245.     TIME_EQUALITY toReturn;
  1247.     /*----------------------------------------------------------------*/
  1248.     /* Code Body                                                      */
  1249.     /*----------------------------------------------------------------*/
  1250.     if (referenceTime.nYear == compareTime.nYear)
  1251.     {
  1252.         if (referenceTime.nMonth == compareTime.nMonth)
  1253.         {
  1254.             if (referenceTime.nDay == compareTime.nDay)
  1255.             {
  1256.                 if (referenceTime.nHour == compareTime.nHour)
  1257.                 {
  1258.                     if (referenceTime.nMin == compareTime.nMin)
  1259.                     {
  1260.                         if (referenceTime.nSec == compareTime.nSec)
  1261.                         {
  1262.                             toReturn = TIME_EQUAL;
  1263.                         }
  1264.                         else
  1265.                         {
  1266.                             if (referenceTime.nSec < compareTime.nSec)
  1267.                             {
  1268.                                 toReturn = TIME_LESS;
  1269.                             }
  1270.                             else
  1271.                             {
  1272.                                 toReturn = TIME_GREATER;
  1273.                             }
  1274.                         }
  1275.                     }
  1276.                     else
  1277.                     {
  1278.                         if (referenceTime.nMin < compareTime.nMin)
  1279.                         {
  1280.                             toReturn = TIME_LESS;
  1281.                         }
  1282.                         else
  1283.                         {
  1284.                             toReturn = TIME_GREATER;
  1285.                         }
  1286.                     }
  1287.                 }
  1288.                 else
  1289.                 {
  1290.                     if (referenceTime.nHour < compareTime.nHour)
  1291.                     {
  1292.                         toReturn = TIME_LESS;
  1293.                     }
  1294.                     else
  1295.                     {
  1296.                         toReturn = TIME_GREATER;
  1297.                     }
  1298.                 }
  1299.             }
  1300.             else
  1301.             {
  1302.                 if (referenceTime.nDay < compareTime.nDay)
  1303.                 {
  1304.                     toReturn = TIME_LESS;
  1305.                 }
  1306.                 else
  1307.                 {
  1308.                     toReturn = TIME_GREATER;
  1309.                 }
  1310.             }
  1311.         }
  1312.         else
  1313.         {
  1314.             if (referenceTime.nMonth < compareTime.nMonth)
  1315.             {
  1316.                 toReturn = TIME_LESS;
  1317.             }
  1318.             else
  1319.             {
  1320.                 toReturn = TIME_GREATER;
  1321.             }
  1322.         }
  1323.     }
  1324.     else
  1325.     {
  1326.         if (referenceTime.nYear < compareTime.nYear)
  1327.         {
  1328.             toReturn = TIME_LESS;
  1329.         }
  1330.         else
  1331.         {
  1332.             toReturn = TIME_GREATER;
  1333.         }
  1334.     }
  1336.     return toReturn;
  1337. }
  1340. /*****************************************************************************
  1341.  * FUNCTION
  1342.  *  mmi_dt_is_valid
  1343.  * DESCRIPTION
  1344.  *  To compute is the date/time is within reasonable range
  1345.  * PARAMETERS
  1346.  *  t       [?]     [?]     Time to be computed
  1347.  * RETURNS
  1348.  *  TURE if date/time valid; otherwise, FALSE
  1349.  *****************************************************************************/
  1350. U8 mmi_dt_is_valid(MYTIME *t)
  1351. {
  1352.     /*----------------------------------------------------------------*/
  1353.     /* Local Variables                                                */
  1354.     /*----------------------------------------------------------------*/
  1356.     /*----------------------------------------------------------------*/
  1357.     /* Code Body                                                      */
  1358.     /*----------------------------------------------------------------*/
  1359.     /* error handling */
  1360.     if (t->nYear > 2030 || t->nYear < YEARFORMATE)
  1361.     {
  1362.         return FALSE;
  1363.     }
  1365.     if (t->nMonth > 12)
  1366.     {
  1367.         return FALSE;
  1368.     }
  1370.     if (t->nMonth == 2)
  1371.     {
  1372.         if (t->nDay > (gDaysInMonth[t->nMonth - 1] + IsLeapYear(t->nYear)))
  1373.         {
  1374.             return FALSE;
  1375.         }
  1376.     }
  1377.     else
  1378.     {
  1379.         if (t->nDay > gDaysInMonth[t->nMonth - 1])
  1380.         {
  1381.             return FALSE;
  1382.         }
  1383.     }
  1385.     if (t->nHour > 23)
  1386.     {
  1387.         return FALSE;
  1388.     }
  1390.     if (t->nMin > 59)
  1391.     {
  1392.         return FALSE;
  1393.     }
  1395.     if (t->nSec > 59)
  1396.     {
  1397.         return FALSE;
  1398.     }
  1400.     return TRUE;
  1402. }
  1405. /*****************************************************************************
  1406.  * FUNCTION
  1407.  *  mmi_conv_tz_to_mytime
  1408.  * DESCRIPTION
  1409.  *  contert timezone to MYTIME structure
  1410.  * PARAMETERS
  1411.  *  tz      [IN]        Time zone to be converted
  1412.  * RETURNS
  1413.  *  result in MYTIME structure
  1414.  *****************************************************************************/
  1415. MYTIME mmi_conv_tz_to_mytime(FLOAT tz)
  1416. {
  1417.     /*----------------------------------------------------------------*/
  1418.     /* Local Variables                                                */
  1419.     /*----------------------------------------------------------------*/
  1420.     MYTIME result;
  1421.     S16 timezone = (S16) (tz * 4);
  1423.     /*----------------------------------------------------------------*/
  1424.     /* Code Body                                                      */
  1425.     /*----------------------------------------------------------------*/
  1426.     memset(&result, 0, sizeof(MYTIME));
  1427.     result.nHour = (U8) (timezone / 4);
  1428.     result.nMin = (U8) ((timezone % 4) * 15);
  1430.     return result;
  1431. }
  1434. /*****************************************************************************
  1435.  * FUNCTION
  1436.  *  mmi_dt_utc_to_rtc
  1437.  * DESCRIPTION
  1438.  *  compute utc time to rtc time
  1439.  * PARAMETERS
  1440.  *  tz      [IN]        Time zone
  1441.  *  utc     [IN]        Utc time
  1442.  * RETURNS
  1443.  *  result of time
  1444.  *****************************************************************************/
  1445. MYTIME mmi_dt_utc_to_rtc(FLOAT tz, MYTIME utc)
  1446. {
  1447.     /*----------------------------------------------------------------*/
  1448.     /* Local Variables                                                */
  1449.     /*----------------------------------------------------------------*/
  1450.     MYTIME result;
  1451.     MYTIME incTime;
  1452.     U8 negative = FALSE;
  1454.     /*----------------------------------------------------------------*/
  1455.     /* Code Body                                                      */
  1456.     /*----------------------------------------------------------------*/
  1457.     if (tz < 0)
  1458.     {
  1459.         negative = TRUE;
  1460.         tz = 0 - tz;
  1461.     }
  1463.     incTime = mmi_conv_tz_to_mytime(tz);
  1465.     if (negative)
  1466.     {
  1467.         DecrementTime(utc, incTime, &result);
  1468.     }
  1469.     else
  1470.     {
  1471.         IncrementTime(utc, incTime, &result);
  1472.     }
  1474.     return result;
  1475. }
  1478. /*****************************************************************************
  1479.  * FUNCTION
  1480.  *  LastDayOfMonth
  1481.  * DESCRIPTION
  1482.  *  Function to find the last day of specific month.
  1483.  * PARAMETERS
  1484.  *  month       [IN]        Month
  1485.  *  year        [IN]        Year
  1486.  * RETURNS
  1487.  *  number of days
  1488.  *****************************************************************************/
  1489. U8 LastDayOfMonth(U8 month, U16 year)
  1490. {
  1491.     /*----------------------------------------------------------------*/
  1492.     /* Local Variables                                                */
  1493.     /*----------------------------------------------------------------*/
  1495.     /*----------------------------------------------------------------*/
  1496.     /* Code Body                                                      */
  1497.     /*----------------------------------------------------------------*/
  1498.     if (month != FEB)
  1499.     {
  1500.         return gDaysInMonth[month - 1];
  1501.     }
  1502.     else
  1503.     {
  1504.         return gDaysInMonth[1] + IsLeapYear(year);
  1505.     }
  1506. }
  1509. /*****************************************************************************
  1510.  * FUNCTION
  1511.  *  IncrementTime
  1512.  * DESCRIPTION
  1513.  *  Increase a reference time by some time
  1514.  * PARAMETERS
  1515.  *  timeToIncrement     [IN]        Time to be increased
  1516.  *  increment           [IN]        
  1517.  *  Result              [IN]        
  1518.  *  decrement(?)        [IN]        Time to increase(?)
  1519.  * RETURNS
  1520.  *  result of computation(?)
  1521.  *****************************************************************************/
  1522. void IncrementTime(MYTIME timeToIncrement, MYTIME increment, MYTIME *Result)
  1523. {
  1524.     /*----------------------------------------------------------------*/
  1525.     /* Local Variables                                                */
  1526.     /*----------------------------------------------------------------*/
  1527.     S16 NumOfDays;
  1529.     /*----------------------------------------------------------------*/
  1530.     /* Code Body                                                      */
  1531.     /*----------------------------------------------------------------*/
  1532.     /* second */
  1533.     Result->nSec = (timeToIncrement.nSec + increment.nSec);
  1535.     /* minute */
  1536.     Result->nMin = (timeToIncrement.nMin + increment.nMin);
  1537.     if (Result->nSec >= NUM_MIN_HR)
  1538.     {
  1539.         Result->nSec -= NUM_MIN_HR;
  1540.         Result->nMin += 1;
  1541.     }
  1543.     /* hour */
  1544.     Result->nHour = (timeToIncrement.nHour + increment.nHour);
  1545.     if (Result->nMin >= NUM_MIN_HR)
  1546.     {
  1547.         Result->nMin -= NUM_MIN_HR;
  1548.         Result->nHour += 1;
  1549.     }
  1551.     /* day */
  1552.     Result->nDay = (timeToIncrement.nDay + increment.nDay);
  1553.     if (Result->nHour >= NUM_HRS_DAY)
  1554.     {
  1555.         Result->nHour -= NUM_HRS_DAY;
  1556.         Result->nDay += +1;
  1557.     }
  1559.     /* month, year */
  1560.     Result->nMonth = timeToIncrement.nMonth + increment.nMonth;
  1561.     Result->nYear = timeToIncrement.nYear + increment.nYear;
  1563.     if (Result->nMonth > NUM_MONTHS)
  1564.     {
  1565.         Result->nMonth -= NUM_MONTHS;
  1566.         Result->nYear++;
  1567.     }
  1569.     /* correct day */
  1570.     NumOfDays = LastDayOfMonth(timeToIncrement.nMonth, timeToIncrement.nYear);
  1572.     if (Result->nDay > NumOfDays)
  1573.     {
  1574.         Result->nDay -= NumOfDays;
  1576.         if (Result->nMonth != DEC)
  1577.         {
  1578.             Result->nMonth += 1;
  1579.         }
  1580.         else
  1581.         {
  1582.             Result->nMonth = JAN;
  1583.             Result->nYear += 1;
  1584.         }
  1585.     }
  1587.     Result->DayIndex = DOW(Result->nYear, Result->nMonth, Result->nDay);
  1588. }
  1590. /*****************************************************************************
  1591.  * FUNCTION
  1592.  *  applib_dt_get_rtc_without_daylight_impact
  1593.  * DESCRIPTION
  1594.  *  
  1595.  * PARAMETERS
  1596.  *  t       [?]     
  1597.  * RETURNS
  1598.  *  void
  1599.  *****************************************************************************/
  1600. void applib_dt_get_rtc_without_daylight_impact(MYTIME *t)
  1601. {
  1602.     /*----------------------------------------------------------------*/
  1603.     /* Local Variables                                                */
  1604.     /*----------------------------------------------------------------*/
  1605.     kal_uint8 dst;
  1606.     MYTIME decreaseDST;
  1607. S16 error;
  1609.     /*----------------------------------------------------------------*/
  1610.     /* Code Body                                                      */
  1611.     /*----------------------------------------------------------------*/
  1612.     DTGetRTCTime((MYTIME*)t);
  1613. ReadValue(NVRAM_SETTING_DT_DST, &dst, DS_BYTE, &error);
  1615.     if (dst)
  1616.     {
  1617.         memset(&decreaseDST, 0, sizeof(MYTIME));
  1618.         decreaseDST.nHour = 1;
  1620.         DecrementTime(*t, decreaseDST, t);
  1621.     }
  1622. }
  1625. /*****************************************************************************
  1626.  * FUNCTION
  1627.  *  applib_dt_modify_dt_with_daylight_impact
  1628.  * DESCRIPTION
  1629.  *  
  1630.  * PARAMETERS
  1631.  *  t       [?]     
  1632.  * RETURNS
  1633.  *  void
  1634.  *****************************************************************************/
  1635. void applib_dt_modify_dt_with_daylight_impact(MYTIME *t)
  1636. {
  1637.     /*----------------------------------------------------------------*/
  1638.     /* Local Variables                                                */
  1639.     /*----------------------------------------------------------------*/
  1640.     kal_uint8 dst;
  1641.     MYTIME increaseDST;
  1642. S16 error;
  1644.     /*----------------------------------------------------------------*/
  1645.     /* Code Body                                                      */
  1646.     /*----------------------------------------------------------------*/
  1647.     ReadValue(NVRAM_SETTING_DT_DST, &dst, DS_BYTE, &error);
  1649.     if (dst)
  1650.     {
  1651.         memset(&increaseDST, 0, sizeof(MYTIME));
  1652.         increaseDST.nHour = 1;
  1654.         IncrementTime(*t, increaseDST, t);
  1655.     }
  1656. }
  1658. /*****************************************************************************
  1659.  * FUNCTION
  1660.  *  mmi_dt_mytime_2_utc_sec
  1661.  * DESCRIPTION
  1662.  *  convert MYTIME format of time to seconds after 1970/1/1
  1663.  * PARAMETERS
  1664.  *  currTime        [?]     
  1665.  * RETURNS
  1666.  *  void
  1667.  *****************************************************************************/
  1668. kal_int32 mmi_dt_mytime_2_utc_sec(MYTIME *currTime, kal_bool daylightSaving)
  1669. {
  1670.     /*----------------------------------------------------------------*/
  1671.     /* Local Variables                                                */
  1672.     /*----------------------------------------------------------------*/
  1673.     kal_uint16 i;
  1674.     kal_uint32 no_of_days = 0;
  1675.     kal_int32 utc_time;
  1676.     kal_int32 is_leap;
  1677.     kal_uint8 dst;
  1678.     S16 error;
  1680.     /*----------------------------------------------------------------*/
  1681.     /* Code Body                                                      */
  1682.     /*----------------------------------------------------------------*/
  1683.     if (currTime->nYear < DT_UTC_BASE_YEAR)
  1684.     {
  1685.         return 0;
  1686.     }
  1688.     /* year */
  1689.     for (i = DT_UTC_BASE_YEAR; i < currTime->nYear; i++)
  1690.     {
  1691.         no_of_days += (365 + IsLeapYear(i));
  1692.     }
  1694.     /* month */
  1695.     is_leap = IsLeapYear(currTime->nYear);
  1696.     for (i = 1; i < currTime->nMonth; i++)
  1697.     {
  1698.         no_of_days += LastDayOfMonth((kal_uint8) i, currTime->nYear);
  1699.     }
  1701.     /* day */
  1702.     no_of_days += (currTime->nDay - 1);
  1704.     /* sec */
  1705.     utc_time =
  1706.         (kal_uint32) no_of_days *DT_SEC_PER_DAY + (kal_uint32) (currTime->nHour * DT_SEC_PER_HOUR +
  1707.                                                                 currTime->nMin * DT_SEC_PER_MIN + currTime->nSec);
  1708.                                                                 
  1709. ReadValue(NVRAM_SETTING_DT_DST, &dst, DS_BYTE, &error);
  1710. if (dst && daylightSaving)
  1711.     {
  1712.         utc_time -= DT_SEC_PER_HOUR;
  1713.     }
  1714.     
  1715.     return utc_time;
  1716. }
  1719. /*****************************************************************************
  1720.  * FUNCTION
  1721.  *  mmi_dt_utc_sec_2_mytime
  1722.  * DESCRIPTION
  1723.  *  convert from UTC second to MYTIME struct
  1724.  * PARAMETERS
  1725.  *  utc_sec     [IN]        Uct_sec
  1726.  *  result      [IN]        Result of time
  1727.  * RETURNS
  1728.  *  TRUE if success; otherwise, FALSE.
  1729.  *****************************************************************************/
  1730. kal_uint8 mmi_dt_utc_sec_2_mytime(kal_int32 utc_sec, MYTIME *result, kal_bool daylightSaving)
  1731. {
  1732.     /*----------------------------------------------------------------*/
  1733.     /* Local Variables                                                */
  1734.     /*----------------------------------------------------------------*/
  1735.     kal_int32 sec, day;
  1736.     kal_uint16 y;
  1737.     kal_uint8 m;
  1738.     kal_uint16 d;
  1739.     kal_uint8 dst;
  1740.     S16 error;
  1742.     /*----------------------------------------------------------------*/
  1743.     /* Code Body                                                      */
  1744.     /*----------------------------------------------------------------*/
  1745.     if (utc_sec < 0)
  1746.     {
  1747.         return KAL_FALSE;
  1748.     }
  1750.     ReadValue(NVRAM_SETTING_DT_DST, &dst, DS_BYTE, &error);
  1752.     if (dst && daylightSaving)
  1753.     {
  1754.         utc_sec += DT_SEC_PER_HOUR;
  1755.     }
  1757.     /* hour, min, sec */
  1758.     /* hour */
  1759.     sec = utc_sec % DT_SEC_PER_DAY;
  1760.     result->nHour = sec / DT_SEC_PER_HOUR;
  1762.     /* min */
  1763.     sec %= DT_SEC_PER_HOUR;
  1764.     result->nMin = sec / DT_SEC_PER_MIN;
  1766.     /* sec */
  1767.     result->nSec = sec % DT_SEC_PER_MIN;
  1769.     /* year, month, day */
  1770.     /* year */
  1771.     /* year */
  1772.     day = utc_sec / DT_SEC_PER_DAY;
  1773.     for (y = DT_UTC_BASE_YEAR; day > 0; y++)
  1774.     {
  1775.         d = (DT_DAY_PER_YEAR + IsLeapYear(y));
  1776.         if (day >= d)
  1777.         {
  1778.             day -= d;
  1779.         }
  1780.         else
  1781.         {
  1782.             break;
  1783.         }
  1784.     }
  1785.     result->nYear = y;
  1787.     for (m = 1; m < DT_MONTH_PER_YEAR; m++)
  1788.     {
  1789.         d = LastDayOfMonth(m, y);
  1790.         if (day >= d)
  1791.         {
  1792.             day -= d;
  1793.         }
  1794.         else
  1795.         {
  1796.             break;
  1797.         }
  1798.     }
  1800.     result->nMonth = m;
  1801.     result->nDay = (kal_uint8) (day + 1);
  1803.     return KAL_TRUE;
  1804. }
  1806. /*****************************************************************************
  1807.  * FUNCTION
  1808.  *  applib_dt_get_week_number
  1809.  * DESCRIPTION
  1810.  *  Compute the week number of a date
  1811.  * PARAMETERS
  1812.  *  date        [?]     
  1813.  * RETURNS
  1814.  *  void
  1815.  *****************************************************************************/
  1816. U8 mmi_dt_get_week_number(MYTIME *date)
  1817. {
  1818.     /*----------------------------------------------------------------*/
  1819.     /* Local Variables                                                */
  1820.     /*----------------------------------------------------------------*/
  1821.     S32 i, no_of_days, week_num, numdays_inmonth, day_on_firstjan;
  1823.     /*----------------------------------------------------------------*/
  1824.     /* Code Body                                                      */
  1825.     /*----------------------------------------------------------------*/
  1826.     no_of_days = date->nDay;
  1828.     for (i = date->nMonth - 1; i > 0; i--)
  1829.     {
  1831.         /* get the num of days in todays month */
  1832.         numdays_inmonth = LastDayOfMonth((U8) i, date->nYear);
  1833.         no_of_days += numdays_inmonth;
  1834.     }
  1836.     day_on_firstjan = DOW(date->nYear, 1, 1);
  1838.     /* Total no of days/ weekdays */
  1839.     no_of_days += day_on_firstjan;
  1841.     week_num = (no_of_days) / DT_DAYS_OF_WEEK;
  1842.     if ((no_of_days) % DT_DAYS_OF_WEEK > 0)
  1843.     {
  1844.         week_num += 1;
  1845.     }
  1847.     ASSERT(week_num <= CLNDR_MAX_WEEK_NUM);
  1848.     return week_num;
  1850. }
  1852. #endif /* MMI_ON_WIN32 */ 
  1855. /*****************************************************************************
  1856.  * FUNCTION
  1857.  *  CMGetExactTime
  1858.  * DESCRIPTION
  1859.  *  Used by CM to get the Exact Time. Asyncronous Call. Callback is passeds
  1860.  * PARAMETERS
  1861.  *  callback        [IN]        Callback function to be called when get time response comes back
  1862.  * RETURNS
  1863.  *  void
  1864.  *****************************************************************************/
  1865. void CMGetExactTime(DateTimeFuncPtr callback)
  1866. {
  1867. #ifdef __MTK_TARGET__
  1868.     /*----------------------------------------------------------------*/
  1869.     /* Local Variables                                                */
  1870.     /*----------------------------------------------------------------*/
  1872.     /*----------------------------------------------------------------*/
  1873.     /* Code Body                                                      */
  1874.     /*----------------------------------------------------------------*/
  1875.     {
  1876.         /* MYTIME curtime;
  1877.            DTGetRTCTime(&curtime);
  1878.            callback(&curtime); */
  1879.         PRINT_INFORMATION(("<<** CMGetExactTime ** >> CMCallCount = %d, CMCallBackCount = %dn", CMCallCount,
  1880.                            CMCallBackCount));
  1881.         CMDateTimeRequest++;
  1882.         CMDateTimeCallBack[CMCallCount++] = callback;
  1883.         if (CMCallCount == MAX_CM_CALLS)
  1884.         {
  1885.             CMCallCount = 0;
  1886.         }
  1887.         L4GetClockTime(CMGetExactTimeCB);
  1889.     }
  1890. #else /* __MTK_TARGET__ */ 
  1891.     {
  1892.         CMDateTimeRequest++;
  1893.         CMDateTimeCallBack[CMCallCount++] = callback;
  1894.         if (CMCallCount == MAX_CM_CALLS)
  1895.         {
  1896.             CMCallCount = 0;
  1897.         }
  1898.         StartTimer(CM_GET_TIME_CALLBACK, 1000, CMCallBackTimer);
  1899.     }
  1900. #endif /* __MTK_TARGET__ */ 
  1901. }
  1904. /*****************************************************************************
  1905.  * FUNCTION
  1906.  *  CMGetExactTimeCB
  1907.  * DESCRIPTION
  1908.  *  
  1909.  * PARAMETERS
  1910.  *  buf     [?]     [?]
  1911.  * RETURNS
  1912.  *  void
  1913.  *****************************************************************************/
  1914. void CMGetExactTimeCB(void *buf)
  1915. {
  1916. #ifdef __MTK_TARGET__
  1917.     /*----------------------------------------------------------------*/
  1918.     /* Local Variables                                                */
  1919.     /*----------------------------------------------------------------*/
  1920.     mmi_eq_get_rtc_time_rsp_struct *local_data = (mmi_eq_get_rtc_time_rsp_struct*) buf;
  1922.     /* Lisen0522 */
  1923.     extern void update_mainlcd_dt_display(void);
  1924.     extern void update_sublcd_dt_display(void);
  1926.     /*----------------------------------------------------------------*/
  1927.     /* Code Body                                                      */
  1928.     /*----------------------------------------------------------------*/
  1929.     SetDateTime(&(local_data->rtctime[0].data_time));
  1930.     /* gclockData.rtc_wday = local_data->rtctime[0].data_time.rtc_wday;
  1931.        gclockData.rtc_year = local_data->rtctime[0].data_time.rtc_year,
  1932.        gclockData.rtc_mon = local_data->rtctime[0].data_time.rtc_mon,
  1933.        gclockData.rtc_day = local_data->rtctime[0].data_time.rtc_day,
  1934.        gclockData.rtc_hour = local_data->rtctime[0].data_time.rtc_hour,
  1935.        gclockData.rtc_min = local_data->rtctime[0].data_time.rtc_min,
  1936.        gclockData.rtc_sec = local_data->rtctime[0].data_time.rtc_sec; */
  1938.     PRINT_INFORMATION(("<<** CMGetExactTimeCB ** >>n"));
  1940.     if (CMDateTimeRequest > 0)
  1941.     {
  1942.         MYTIME curtime;
  1944.         PRINT_INFORMATION(("<<** CMGetExactTimeCB ** >> CMCallCount = %d, CMCallBackCount = %dn", CMCallCount,
  1945.                            CMCallBackCount));
  1947.         GetDateTime(&curtime);
  1948.         CMDateTimeCallBack[CMCallBackCount++] (&curtime);
  1949.         if (CMCallBackCount == MAX_CM_CALLS)
  1950.         {
  1951.             CMCallBackCount = 0;
  1952.         }
  1953.         CMDateTimeRequest--;
  1954.         return;
  1955.     }
  1957.     /* Lisen0522 */
  1958.     update_mainlcd_dt_display();
  1959.     update_sublcd_dt_display();
  1960. #endif /* __MTK_TARGET__ */ 
  1961. }
  1964. /*****************************************************************************
  1965.  * FUNCTION
  1966.  *  CMCallBackTimer
  1967.  * DESCRIPTION
  1968.  *  Used to simulate CM time function on widows. Calls CM Callback function as set by CM
  1969.  * PARAMETERS
  1970.  *  void
  1971.  * RETURNS
  1972.  *  void
  1973.  *****************************************************************************/
  1974. void CMCallBackTimer(void)
  1975. {
  1976.     /*----------------------------------------------------------------*/
  1977.     /* Local Variables                                                */
  1978.     /*----------------------------------------------------------------*/
  1980.     /*----------------------------------------------------------------*/
  1981.     /* Code Body                                                      */
  1982.     /*----------------------------------------------------------------*/
  1983.     if (CMDateTimeRequest)
  1984.     {
  1985.         MYTIME curtime;
  1987.         GetDateTime(&curtime);
  1988.         CMDateTimeCallBack[CMCallBackCount++] (&curtime);
  1989.         if (CMCallBackCount == MAX_CM_CALLS)
  1990.         {
  1991.             CMCallBackCount = 0;
  1992.         }
  1993.         CMDateTimeRequest--;
  1994.     }
  1995. }
  1998. /*****************************************************************************
  1999.  * FUNCTION
  2000.  *  mmi_dt_get_tz
  2001.  * DESCRIPTION
  2002.  *  Get current time zone of MMI
  2003.  * PARAMETERS
  2004.  *  void
  2005.  * RETURNS
  2006.  *  time zone of current home city.
  2007.  *****************************************************************************/
  2008. FLOAT mmi_dt_get_tz(void)
  2009. {
  2010.     /*----------------------------------------------------------------*/
  2011.     /* Local Variables                                                */
  2012.     /*----------------------------------------------------------------*/
  2014.     /*----------------------------------------------------------------*/
  2015.     /* Code Body                                                      */
  2016.     /*----------------------------------------------------------------*/
  2017.     return GetTimeZone(PhnsetGetHomeCity());
  2018. }
  2020. /*****************************************************************************
  2021.  * FUNCTION
  2022.  *  mmi_dt_set_dst
  2023.  * DESCRIPTION
  2024.  *  
  2025.  * PARAMETERS
  2026.  *  dst     [IN]        
  2027.  * RETURNS
  2028.  *  void
  2029.  *****************************************************************************/
  2030. void mmi_dt_set_dst(U8 dst)
  2031. {
  2032.     /*----------------------------------------------------------------*/
  2033.     /* Local Variables                                                */
  2034.     /*----------------------------------------------------------------*/
  2035.     S16 error;
  2037.     /*----------------------------------------------------------------*/
  2038.     /* Code Body                                                      */
  2039.     /*----------------------------------------------------------------*/
  2040.     WriteValue(NVRAM_SETTING_DT_DST, &dst, DS_BYTE, &error);
  2041.     g_dst = (U8) dst;
  2042. }
  2044. #if 0
  2045. /* under construction !*/
  2046. /* under construction !*/
  2047. /* under construction !*/
  2048. /* under construction !*/
  2049. /* under construction !*/
  2050. #endif /* 0 */ 
  2053. /*****************************************************************************
  2054.  * FUNCTION
  2055.  *  mmi_dt_set_rtc_dt
  2056.  * DESCRIPTION
  2057.  *  This function is to send set time request to L4
  2058.  *  Functionality:
  2059.  * PARAMETERS
  2060.  *  t       [?]     [?]
  2061.  *  a(?)        [IN/OUT](?)
  2062.  *  b(?)        [IN](?)
  2063.  * RETURNS
  2064.  *  void
  2065.  *****************************************************************************/
  2066. void mmi_dt_set_rtc_dt(MYTIME *t)
  2067. {
  2068. #ifdef __MTK_TARGET__
  2069.     /*----------------------------------------------------------------*/
  2070.     /* Local Variables                                                */
  2071.     /*----------------------------------------------------------------*/
  2072.     MYQUEUE msgStruct;
  2073.     RTCTIMEFORMAT *time;
  2075.     /*----------------------------------------------------------------*/
  2076.     /* Code Body                                                      */
  2077.     /*----------------------------------------------------------------*/
  2078.     time = OslConstructDataPtr(sizeof(RTCTIMEFORMAT));
  2079.     time->info.alarm_format = 0;
  2080.     time->info.alarm_index = 0;
  2081.     time->info.type = 0;
  2082.     time->info.text[0] = '';
  2083.     time->info.recurr = 0;
  2084.     time->info.data_time.rtc_sec = 0;
  2085.     time->info.data_time.rtc_min = t->nMin;
  2086.     time->info.data_time.rtc_hour = t->nHour;
  2088.     time->rtc_type = RTC_TIME_CLOCK_IND;
  2089.     time->set_type = RTC_SETTING_TYPE_DATETIME;
  2090.     time->info.data_time.rtc_day = t->nDay;
  2091.     time->info.data_time.rtc_mon = t->nMonth;
  2092.     time->info.data_time.rtc_year = t->nYear - YEARFORMATE;
  2093.     time->info.data_time.rtc_wday = applib_dt_dow(t->nYear, t->nMonth, t->nDay);
  2095.     msgStruct.oslSrcId = MOD_MMI;
  2096.     msgStruct.oslDestId = MOD_L4C;
  2097.     msgStruct.oslMsgId = HW_SET_TIME_REQ;
  2098.     msgStruct.oslSapId = 0;
  2099.     msgStruct.oslDataPtr = (oslParaType*) time;
  2100.     msgStruct.oslPeerBuffPtr = NULL;
  2101.     OslMsgSendExtQueue(&msgStruct);
  2102. #else /* __MTK_TARGET__ */ 
  2103.     MyTime = *t;
  2104. #endif /* __MTK_TARGET__ */ 
  2105. }
  2107. #ifndef MMI_ON_WIN32
  2110. /*****************************************************************************
  2111.  * FUNCTION
  2112.  *  SetDateTime
  2113.  * DESCRIPTION
  2114.  *  Function to set date and time information to global variable of MMI
  2115.  * PARAMETERS
  2116.  *  t       [IN]        Struct variable that stores date and time information from PS
  2117.  * RETURNS
  2118.  *  void
  2119.  *****************************************************************************/
  2120. void SetDateTime(void *t)
  2121. {
  2122.     /*----------------------------------------------------------------*/
  2123.     /* Local Variables                                                */
  2124.     /*----------------------------------------------------------------*/
  2125.     rtc_format_struct *local_data = (rtc_format_struct*) t;
  2127.     /*----------------------------------------------------------------*/
  2128.     /* Code Body                                                      */
  2129.     /*----------------------------------------------------------------*/
  2130. #ifdef __MTK_TARGET__
  2132.     gclockData.rtc_wday = local_data->rtc_wday;
  2133.     gclockData.rtc_year = local_data->rtc_year;
  2134.     gclockData.rtc_mon = local_data->rtc_mon;
  2135.     gclockData.rtc_day = local_data->rtc_day;
  2136.     gclockData.rtc_hour = local_data->rtc_hour;
  2137.     gclockData.rtc_min = local_data->rtc_min;
  2138.     gclockData.rtc_sec = local_data->rtc_sec;
  2140.     if (gclockData.rtc_year > MMI_DT_YEAR_BOUNDARY)
  2141.     {
  2142.         gclockData.rtc_year = 0;    /* reset to 2000 */
  2143.         DTResetTime();
  2144.     }
  2145. #else /* __MTK_TARGET__ */ 
  2146.     MyTime.DayIndex = local_data->rtc_wday;
  2147.     MyTime.nYear = local_data->rtc_year;
  2148.     MyTime.nMonth = local_data->rtc_mon;
  2149.     MyTime.nDay = local_data->rtc_day;
  2150.     MyTime.nHour = local_data->rtc_hour;
  2151.     MyTime.nMin = local_data->rtc_min;
  2152.     MyTime.nSec = local_data->rtc_sec;
  2153. #endif /* __MTK_TARGET__ */ 
  2154. }
  2157. /*****************************************************************************
  2158.  * FUNCTION
  2159.  *  DTResetTimeRsp
  2160.  * DESCRIPTION
  2161.  *  Response handler of reset date/time.
  2162.  * PARAMETERS
  2163.  *  rsp     [?]     [?]
  2164.  * RETURNS
  2165.  *  void
  2166.  *****************************************************************************/
  2167. void DTResetTimeRsp(void *rsp)
  2168. {
  2169. #ifndef MMI_ON_WIN32
  2170.     /*----------------------------------------------------------------*/
  2171.     /* Local Variables                                                */
  2172.     /*----------------------------------------------------------------*/
  2174.     /*----------------------------------------------------------------*/
  2175.     /* Code Body                                                      */
  2176.     /*----------------------------------------------------------------*/
  2177.     AlmReInitialize();
  2178.     SetProtocolEventHandler(L4SetClockRSP, MSG_ID_MMI_EQ_SET_RTC_TIME_RSP);
  2179. #endif /* MMI_ON_WIN32 */ 
  2180. }
  2183. /*****************************************************************************
  2184.  * FUNCTION
  2185.  *  DTResetTime
  2186.  * DESCRIPTION
  2187.  *  Reset Date/Time function when time reaches boundary
  2188.  * PARAMETERS
  2189.  *  void
  2190.  * RETURNS
  2191.  *  void
  2192.  *****************************************************************************/
  2193. static void DTResetTime(void)
  2194. {
  2195. #ifndef MMI_ON_WIN32
  2196.     /*----------------------------------------------------------------*/
  2197.     /* Local Variables                                                */
  2198.     /*----------------------------------------------------------------*/
  2199.     MYQUEUE msgStruct;
  2200.     mmi_eq_set_rtc_time_req_struct *time;
  2202.     /*----------------------------------------------------------------*/
  2203.     /* Code Body                                                      */
  2204.     /*----------------------------------------------------------------*/
  2205.     time = OslConstructDataPtr(sizeof(mmi_eq_set_rtc_time_req_struct));
  2206.     time->info.alarm_format = 0;
  2207.     time->info.alarm_index = 0;
  2208.     time->info.type = 0;
  2209.     time->info.text[0] = '';
  2210.     time->info.recurr = 0;
  2212.     time->rtc_type = RTC_TIME_CLOCK_IND;
  2213.     time->set_type = RTC_SETTING_TYPE_DATETIME;
  2214.     time->info.data_time.rtc_sec = 0;
  2215.     time->info.data_time.rtc_min = gclockData.rtc_min;
  2216.     time->info.data_time.rtc_hour = gclockData.rtc_hour;
  2217.     time->info.data_time.rtc_day = gclockData.rtc_day;
  2218.     time->info.data_time.rtc_mon = gclockData.rtc_mon;
  2219.     time->info.data_time.rtc_wday = gclockData.rtc_wday;
  2220.     time->info.data_time.rtc_year = gclockData.rtc_year;
  2222.     msgStruct.oslSrcId = MOD_MMI;
  2223.     msgStruct.oslDestId = MOD_L4C;
  2224.     msgStruct.oslMsgId = MSG_ID_MMI_EQ_SET_RTC_TIME_REQ;
  2225.     msgStruct.oslSapId = 0;
  2226.     msgStruct.oslDataPtr = (oslParaType*) time;
  2227.     msgStruct.oslPeerBuffPtr = NULL;
  2228.     OslMsgSendExtQueue(&msgStruct);
  2230.     SetProtocolEventHandler(DTResetTimeRsp, MSG_ID_MMI_EQ_SET_RTC_TIME_RSP);
  2232. #endif /* MMI_ON_WIN32 */ 
  2233. }
  2236. /*****************************************************************************
  2237.  * FUNCTION
  2238.  *  DateTimerIndication
  2239.  * DESCRIPTION
  2240.  *  Handler of MSG_ID_MMI_EQ_CLOCK_TICK_IND.
  2241.  *  1. Update global variable in MMI.
  2242.  *  2. Update date/time display in IDLE screen.
  2243.  * PARAMETERS
  2244.  *  p       [?]     [?]
  2245.  *  t(?)        [IN]        Struct variable that stores date and time information from PS(?)
  2246.  * RETURNS
  2247.  *  void
  2248.  *****************************************************************************/
  2249. void DateTimerIndication(void *p)
  2250. {
  2251.     /*----------------------------------------------------------------*/
  2252.     /* Local Variables                                                */
  2253.     /*----------------------------------------------------------------*/
  2255. #ifdef __MTK_TARGET__
  2256.     mmi_eq_clock_tick_ind_struct *local_data = (mmi_eq_clock_tick_ind_struct*) p;
  2258.     /*----------------------------------------------------------------*/
  2259.     /* Code Body                                                      */
  2260.     /*----------------------------------------------------------------*/
  2261.     gclockData.rtc_wday = local_data->rtc_time.rtc_wday;
  2262.     gclockData.rtc_year = local_data->rtc_time.rtc_year;
  2263.     gclockData.rtc_mon = local_data->rtc_time.rtc_mon;
  2264.     gclockData.rtc_day = local_data->rtc_time.rtc_day;
  2265.     gclockData.rtc_hour = local_data->rtc_time.rtc_hour;
  2266.     gclockData.rtc_min = local_data->rtc_time.rtc_min;
  2267.     gclockData.rtc_sec = local_data->rtc_time.rtc_sec;
  2269.     if (gclockData.rtc_year > MMI_DT_YEAR_BOUNDARY)
  2270.     {
  2271.         gclockData.rtc_year = 0;    /* reset to 2000 */
  2272.         DTResetTime();
  2273.     }
  2275. #ifdef __DAILY_WALLPAPER__
  2276.     if ((mmi_bootup_is_searching_or_idle_reached() == MMI_TRUE) && (GetWallpaperRotateStatus() == MMI_TRUE))
  2277.     {
  2278.         if (gWallpaperChangeDate.rtc_year == 0xFF
  2279.             || gWallpaperChangeDate.rtc_mon == 0xFF || gWallpaperChangeDate.rtc_day == 0xFF)
  2280.         {
  2281.             gWallpaperChangeDate.rtc_wday = gclockData.rtc_wday;
  2282.             gWallpaperChangeDate.rtc_year = gclockData.rtc_year;
  2283.             gWallpaperChangeDate.rtc_mon = gclockData.rtc_mon;
  2284.             gWallpaperChangeDate.rtc_day = gclockData.rtc_day;
  2285.             gWallpaperChangeDate.rtc_hour = gclockData.rtc_hour;
  2286.             gWallpaperChangeDate.rtc_min = gclockData.rtc_min;
  2287.             gWallpaperChangeDate.rtc_sec = gclockData.rtc_sec;
  2288.         }
  2289.         else if (gWallpaperChangeDate.rtc_year != gclockData.rtc_year
  2290.                  || gWallpaperChangeDate.rtc_mon != gclockData.rtc_mon
  2291.                  || gWallpaperChangeDate.rtc_day != gclockData.rtc_day)
  2292.         {
  2293.             /* S16 error; */
  2294.             WallPaperDailyChange();
  2295.             gWallpaperChangeDate.rtc_wday = gclockData.rtc_wday;
  2296.             gWallpaperChangeDate.rtc_year = gclockData.rtc_year;
  2297.             gWallpaperChangeDate.rtc_mon = gclockData.rtc_mon;
  2298.             gWallpaperChangeDate.rtc_day = gclockData.rtc_day;
  2299.             gWallpaperChangeDate.rtc_hour = gclockData.rtc_hour;
  2300.             gWallpaperChangeDate.rtc_min = gclockData.rtc_min;
  2301.             gWallpaperChangeDate.rtc_sec = gclockData.rtc_sec;
  2302.             /* WriteRecord(NVRAM_MMI_EF_WALLPAPER_MODTIME_LID,1,(void *)&gWallpaperChangeDate, sizeof(gWallpaperChangeDate), &error); */
  2303.         }
  2304.     }
  2305. #endif /* __DAILY_WALLPAPER__ */ 
  2307. #ifdef __MMI_LCD_PARTIAL_ON__
  2308.     if ((mmi_bootup_is_searching_or_idle_reached() == MMI_TRUE) || mmi_bootup_is_sim_removed() == MMI_TRUE)
  2309.     {
  2310.         RedrawPartialOnScreenSaverIfOk();
  2311.     }
  2312. #endif /* __MMI_LCD_PARTIAL_ON__ */ 
  2314.     /* Lisen0522 */
  2315. #if !defined(__MMI_GPIO_DISABLE_SLEEP_MODE__)
  2316.     if (gIsInSleepMode == KAL_FALSE)
  2317.     {
  2318.         update_mainlcd_dt_display();
  2319.     }
  2320. #else /* !defined(__MMI_GPIO_DISABLE_SLEEP_MODE__) */ 
  2321.     update_mainlcd_dt_display();
  2322. #endif /* !defined(__MMI_GPIO_DISABLE_SLEEP_MODE__) */ 
  2323.     update_sublcd_dt_display();
  2325. #else /* __MTK_TARGET__ */ 
  2326.     DateTimerProc();
  2327. #endif /* __MTK_TARGET__ */ 
  2328. }
  2330. /*****************************************************************************
  2331.  * FUNCTION
  2332.  *  mmi_dt_check_rtc_time
  2333.  * DESCRIPTION
  2334.  * Check if rtc time is valid
  2335.  * PARAMETERS
  2336.  *  p       [?]     [?]
  2337.  *  t(?)        [IN]        Struct variable that stores date and time information from PS(?)
  2338.  * RETURNS
  2339.  *  void
  2340.  *****************************************************************************/
  2341. void mmi_dt_check_rtc_time(void)
  2342. {
  2343.     if (gclockData.rtc_year > MMI_DT_YEAR_BOUNDARY)
  2344.     {
  2345.         gclockData.rtc_year = 0;    /* reset to 2000 */
  2346.         DTResetTime();
  2347.     }
  2348. }
  2349. #endif /* MMI_ON_WIN32 */ 
  2350. #endif /* _MMI_DATETIME_C */ // #ifndef _MMI_DATETIME_C