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

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

MTK

开发平台：

C/C++

NITZ.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.  * NITZ.c
  41.  *
  42.  * Project:
  43.  * --------
  44.  * MAUI
  45.  *
  46.  * Description:
  47.  * ------------
  48.  * This file implements interface and message handler for NITZ.
  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.  *------------------------------------------------------------------------------
  169.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  170.  *============================================================================
  171.  ****************************************************************************/
  172. /**
  173.  * Copyright Notice
  174.  * ?2002 - 2003, Pixtel Communications, Inc., 1489 43rd Ave. W.,
  175.  * Vancouver, B.C. V6M 4K8 Canada. All Rights Reserved.
  176.  *  (It is illegal to remove this copyright notice from this software or any
  177.  *  portion of it)
  178.  */
  179. /**************************************************************
  180.    FILENAME : NITZ.c
  181.    PURPOSE     : NITZ Source File
  182.    REMARKS     : nil
  183.    AUTHOR      : Restructured by Gurinder
  184.    DATE     : Restructured on Dec-01-2003
  185. **************************************************************/
  186. #ifndef _MMI_NITZ_C
  187. #define _MMI_NITZ_C
  189. #include "MMI_features.h"
  190. #if defined(__MMI_NITZ__)
  192. #include "NITZ.h"
  193. #include "Stdc.h"
  194. #include "L4Dr1.h"
  195. #include "L4Dr.h"
  196. #include "EventsGprot.h"
  197. #include "CustDataRes.h"
  198. #include "HistoryGprot.h"
  199. #include "wgui_categories.h"
  200. #include "Unicodexdcl.h"
  201. #include "DateTimeGprot.h"
  202. #include "GlobalDefs.h"
  203. #include "ProtocolEvents.h"
  204. #include "SettingGprots.h"
  205. #include "NVRAMType.h"
  206. #include "NVRAMProt.h"
  207. #include "NVRAMEnum.h"
  208. #include "KeyBrd.h"
  209. #include "SettingProfile.h"
  210. #include "gpioInc.h"
  211. #include "SettingProt.h"
  212. #include "IdleAppDef.h"
  213. #include "PhoneSetupGprots.h"
  214. #include "SimDetectionDef.h"
  215. #include "SimDetectionGexdcl.h"
  216. #include "CallsDefs.h"
  217. #ifdef __MMI_NITZ_TZ_SUPPORT__
  218. #include "worldclock.h"
  219. #include "app_datetime.h"
  220. #include "DatetimeGprot.h"
  221. #endif /* __MMI_NITZ_TZ_SUPPORT__ */ 
  223. /* 
  224.  * Define
  225.  */
  226. #define NITZ_SIGN_BIT   0x08
  227. #define NITZ_HIGH_BIT   0xF0
  228. #define NITZ_LOW_BIT 0x0F
  229. #define NITZ_TZ_BIT  0x07
  231. #define NITZ_TIME_LEN      20*ENCODING_LENGTH
  232. #define NITZ_MAX_ALLOW_DIFF   15
  233. /* 
  234.  * Typedef 
  235.  */
  237. /* 
  238.  * Local Variable
  239.  */
  240. nitz_context_struct g_nitz_cntx;
  241. static S16 nitzTempTZ;
  242. #ifdef __MMI_NITZ_TZ_SUPPORT__
  243. static S16 nitzTempDST;
  244. #endif /* __MMI_NITZ_TZ_SUPPORT__ */ 
  246. /* 
  247.  * Local Function
  248.  */
  250. /* 
  251.  * Global Variable
  252.  */
  253. extern wgui_inline_item wgui_inline_items[];
  254. extern MYTIME MyTime;
  255. extern rtc_format_struct gclockData;
  256. /* 
  257.  * Global Function
  258.  */
  259. extern void PhnsetSetDT(void);
  260. extern void EntryPhnsetTimeAndDate(void);
  261. extern void EntryIdleScreen(void);
  262. extern FLOAT GetTimeZone(U8 cityIndex);
  263. extern void EntryPhnsetSetDT(void);
  264. extern void mmi_idle_update_opname_from_nitz(void);
  267. /*****************************************************************************
  268.  * FUNCTION
  269.  *  NITZHandlerInit
  270.  * DESCRIPTION
  271.  *  NITZ Initlization function,
  272.  *  Set the global variable of NITZ to default and register NITZ indication handler.
  273.  * PARAMETERS
  274.  *  void
  275.  * RETURNS
  276.  *  void
  277.  *****************************************************************************/
  278. void NITZHandlerInit(void)
  279. {
  280.     /*----------------------------------------------------------------*/
  281.     /* Local Variables                                                */
  282.     /*----------------------------------------------------------------*/
  283.     S16 error;
  284.     
  285.     /*----------------------------------------------------------------*/
  286.     /* Code Body                                                      */
  287.     /*----------------------------------------------------------------*/
  288.     SetProtocolEventHandler(NITZHandler, PRT_MSG_ID_MMI_NW_TIME_ZONE_IND);
  289.     memset(&g_nitz_cntx, 0, sizeof(nitz_context_struct));
  290.     g_nitz_cntx.NITZTimeZone = (S16) 0xffff;
  291.     /* init PLMN */
  292.     mmi_nitz_get_nitz_nw_name(NULL, g_nitz_cntx.NWShortName, MAX_NW_LEN *ENCODING_LENGTH, NULL);
  293. #ifdef __MMI_NITZ_TZ_SUPPORT__    
  294.     /* init timezone */
  295.     ReadValue(NVRAM_TIMEZONE, &(g_nitz_cntx.NITZTimeZone), DS_SHORT, &error);
  296.     
  297.     /* init dst */
  298.     ReadValue(NVRAM_SETTING_DT_DST, &(g_nitz_cntx.NITZDST), DS_BYTE, &error);
  299. #endif /* __MMI_NITZ_TZ_SUPPORT__ */    
  300. }
  303. /*****************************************************************************
  304.  * FUNCTION
  305.  *  NITZHandler
  306.  * DESCRIPTION
  307.  *  NITZ Inidcation Handler, Thi function checks the diffrence in time zone,
  308.  *  if diffrence is not zero, it set NITZ occurance to true and entry NITZ screen.
  309.  * PARAMETERS
  310.  *  msg     [?]     
  311.  * RETURNS
  312.  *  void
  313.  *****************************************************************************/
  314. void NITZHandler(void *msg)
  315. {
  316.     /*----------------------------------------------------------------*/
  317.     /* Local Variables                                                */
  318.     /*----------------------------------------------------------------*/
  319.     mmi_nw_time_zone_ind_struct *msgReq;
  320.     MYTIME refTime1;
  321.     FLOAT NetTimeZone;
  322.     U8 updateShortNW = 0, updateFullNW = 0;
  324.     /*----------------------------------------------------------------*/
  325.     /* Code Body                                                      */
  326.     /*----------------------------------------------------------------*/
  327.     memset(&refTime1, 0, sizeof(MYTIME));
  330.     if (!PhnsetGetNITZFuncStatus())
  331.     {
  332.         return;
  333.     }
  335.     msgReq = (mmi_nw_time_zone_ind_struct*) msg;
  337.     if (msgReq->nw_time_zone_timeP)
  338.     {
  339.         /* compare network timezone and last recevied timezone */
  340.         refTime1.nYear = NITZConvertTime(msgReq->nw_time_zone_time.year) + YEARFORMATE;
  341.         refTime1.nMonth = NITZConvertTime(msgReq->nw_time_zone_time.month);
  342.         refTime1.nDay = NITZConvertTime(msgReq->nw_time_zone_time.day);
  343.         refTime1.nHour = NITZConvertTime(msgReq->nw_time_zone_time.hour);
  344.         refTime1.nMin = NITZConvertTime(msgReq->nw_time_zone_time.min);
  345.         refTime1.nSec = NITZConvertTime(msgReq->nw_time_zone_time.sec);
  347.         nitzTempTZ = NITZGetTimeZone(msgReq->nw_time_zone_time.time_zone);
  348.         NetTimeZone = (FLOAT) nitzTempTZ;
  349.         NetTimeZone /= 4;
  351.         mmi_dt_utc_to_rtc(NetTimeZone, refTime1, g_nitz_cntx.NITZTime);
  352.     }
  353. #ifdef __MMI_NITZ_TZ_SUPPORT__
  354.     /* Time Zone Support */
  355.     if (msgReq->nw_time_zoneP)
  356.     {
  357.         g_nitz_cntx.TimeZoneP = MMI_TRUE;
  358.         nitzTempTZ = NITZGetTimeZone(msgReq->nw_time_zone);
  359.     }
  360.     else
  361.     {
  362.         g_nitz_cntx.TimeZoneP = MMI_FALSE;
  363.     }
  365.     /* DST Support */
  366.     if (msgReq->nw_day_light_saving_timeP)
  367.     {
  368.         nitzTempDST = msgReq->nw_day_light_saving_time & 0x03;
  369.     }
  370.     else
  371.     {
  372.         nitzTempDST = 0;
  373.     }
  374. #endif
  376.     if (msgReq->short_nw_nameP)
  377.     {
  378.         updateShortNW = mmi_nitz_get_nw_name(
  379.                             msgReq->short_nw_name_dcs,
  380.                             msgReq->short_nw_name_len,
  381.                             (BOOL) msgReq->short_nw_name_add_ci,
  382.                             (S8*) g_nitz_cntx.NWShortName,
  383.                             (S8*) msgReq->short_nw_name);
  384.     }
  385.     else    /* no time information, return */
  386.     {
  387.         memset(g_nitz_cntx.NWShortName, 0, MAX_NW_LEN * ENCODING_LENGTH);
  388.     }
  390.     if (msgReq->short_nw_name_len == 0 && msgReq->full_nw_nameP)
  391.     {
  392.         updateFullNW = mmi_nitz_get_nw_name(
  393.                         msgReq->full_nw_name_dcs,
  394.                         msgReq->full_nw_name_len,
  395.                         (BOOL) msgReq->full_nw_name_add_ci,
  396.                         (S8*) g_nitz_cntx.NWFullName,
  397.                         (S8*) msgReq->full_nw_name);
  398.     }
  399.     else
  400.     {
  401.         memset(g_nitz_cntx.NWFullName, 0, MAX_NW_LEN * ENCODING_LENGTH);
  402.     }
  403.     
  404.     DTGetRTCTime(&g_nitz_cntx.RecvTime);
  405.         
  406.     /* if the nitz does not include information we support, return directly */
  407.     if (!mmi_nitz_check_dt()
  408. #ifdef __MMI_NITZ_TZ_SUPPORT__
  409.         && !mmi_nitz_check_tz()
  410. #endif 
  411.         )
  412.     {
  413.         /* if short name matched, it means short name has been displayed in idle screen */
  414.         if (updateShortNW == MMI_FALSE && updateFullNW == MMI_FALSE)
  415.         {
  416.             return;
  417.         }        
  418.         
  419.     }
  421.     g_nitz_cntx.IsNITZPending = MMI_TRUE;
  422.     if (g_idle_context.IsOnIdleScreen)
  423.     {
  424. EntryIdleScreen();
  425.     }
  426. }
  428. /*****************************************************************************
  429.  * FUNCTION
  430.  *  mmi_nitz_get_nw_name
  431.  * DESCRIPTION
  432.  *  This function is used to get NITZ network name.
  433.  * PARAMETERS
  434.  *  dcs         [IN]        
  435.  *  len         [IN]        
  436.  *  add_ci      [IN]        
  437.  *  dstStr      [?]         
  438.  *  srcStr      [?]         
  439.  * RETURNS
  440.  *  void
  441.  *****************************************************************************/
  442. U8 mmi_nitz_get_nw_name(U8 dcs, U8 len, BOOL add_ci, S8 *dstStr, S8 *srcStr)
  443. {
  444.     /*----------------------------------------------------------------*/
  445.     /* Local Variables                                                */
  446.     /*----------------------------------------------------------------*/
  448.     S8 *nwStr, *tmpStr, *tempStr2;
  449.     U8 count = 0;
  451.     /*----------------------------------------------------------------*/
  452.     /* Code Body                                                      */
  453.     /*----------------------------------------------------------------*/
  454.     if (len == 0)
  455.     {
  456. if (pfnUnicodeStrlen((S8*)dstStr) > 0)
  457.         {
  458.             memset(dstStr, 0, MAX_NW_LEN * ENCODING_LENGTH);
  459.             return MMI_TRUE;
  460.         }
  461.         else
  462.         {
  463.             return MMI_FALSE;
  464.         }
  465.     }
  467.     nwStr = OslMalloc(MAX_NW_LEN * ENCODING_LENGTH);
  468.     memset(nwStr, 0, MAX_NW_LEN * ENCODING_LENGTH);
  470.     switch (dcs)
  471.     {
  472.         case SMSAL_DEFAULT_DCS:
  473.             AnsiiNToUnicodeString(nwStr, srcStr, (U32) MAX_NW_LEN);
  474.             break;
  475.         case SMSAL_UCS2_DCS:
  476.             memcpy(nwStr, srcStr, MAX_NW_LEN * ENCODING_LENGTH);
  477.         default:
  478.             break;
  479.     }
  480.     g_nitz_cntx.AddCI = add_ci;
  482.     /* compare PLMN name */
  483.     tmpStr = dstStr;
  484.     tempStr2 = nwStr;
  485.     while (count < MAX_NW_LEN)
  486.     {
  487.         count++;
  488.         if ((*tmpStr == *tempStr2) && (*(tmpStr + 1) == *(tempStr2 + 1)))
  489.         {
  490.             tmpStr += 2;
  491.             tempStr2 += 2;
  492.         }
  493.         else
  494.         {
  495.             break;
  496.         }
  497.     }   /* End of while */
  499.     if (count < MAX_NW_LEN)
  500.     {
  501.         memcpy(dstStr, nwStr, MAX_NW_LEN * ENCODING_LENGTH);
  502.         OslMfree(nwStr);
  503.         return MMI_TRUE;
  504.     }
  505.     else
  506.     {
  507.         OslMfree(nwStr);
  508.         return MMI_FALSE;
  509.     }
  511. }
  513. /*****************************************************************************
  514.  * FUNCTION
  515.  *  EntryNitzScreen
  516.  * DESCRIPTION
  517.  *  Show the NITZ chnage in time popup,
  518.  *  if NITZ happend and control is on the idle screen.
  519.  * PARAMETERS
  520.  *  void
  521.  * RETURNS
  522.  *  void
  523.  *****************************************************************************/
  524. void EntryNitzScreen(void)
  525. {
  526.     /*----------------------------------------------------------------*/
  527.     /* Local Variables                                                */
  528.     /*----------------------------------------------------------------*/
  529.     U8 *guiBuffer;
  531.     /*----------------------------------------------------------------*/
  532.     /* Code Body                                                      */
  533.     /*----------------------------------------------------------------*/
  535.     EntryNewScreen(SCR_ID_NITZ, ExitNitzScreen, NULL, NULL);
  537.     ClearKeyEvents();
  539.     guiBuffer = GetCurrGuiBuffer(SCR_ID_NITZ);
  541.     NITZMessageString();
  542.     if (g_keylock_context.gKeyPadLockFlag == 0)
  543.     {
  545.         /* start the back light */
  546.         TurnOnBacklight(1);
  548.         ShowCategory7Screen(
  549.             CHANGE_TIME_CAPTION,
  550.             CHANGE_TIME_IMAGE,
  551.             STR_GLOBAL_YES,
  552.             IMG_GLOBAL_YES,
  553.             STR_GLOBAL_NO,
  554.             IMG_GLOBAL_NO,
  555.             (U8*) g_nitz_cntx.Message,
  556.             guiBuffer);
  557.         playRequestedTone(GENERAL_TONE);
  558.         SetLeftSoftkeyFunction(NITZAccept, KEY_EVENT_UP);
  559.         SetRightSoftkeyFunction(NITZIgnore, KEY_EVENT_UP);
  560.         SetKeyHandler(NITZIgnore, KEY_END, KEY_EVENT_DOWN);
  562.     }
  563.     else
  564.     {
  565.         ShowCategory141Screen(
  566.             0,
  567.             0,
  568.             g_keylock_context.KeyLockLSKStringID,
  569.             g_keylock_context.KeyLockLSKIconID,
  570.             g_keylock_context.KeyLockRSKStringID,
  571.             g_keylock_context.KeyLockRSKIconID,
  572.             (U8*) g_nitz_cntx.Message,
  573.             0,
  574.             NULL);
  575.         OslMfree(g_nitz_cntx.Message);
  576.         g_nitz_cntx.Message = NULL;
  577.     }
  578. }
  581. /*****************************************************************************
  582.  * FUNCTION
  583.  *  ExitNitzScreen
  584.  * DESCRIPTION
  585.  *  Exit function of NITZ screen, free memory.
  586.  * PARAMETERS
  587.  *  void
  588.  * RETURNS
  589.  *  void
  590.  *****************************************************************************/
  591. void ExitNitzScreen(void)
  592. {
  593.     /*----------------------------------------------------------------*/
  594.     /* Local Variables                                                */
  595.     /*----------------------------------------------------------------*/
  597.     /*----------------------------------------------------------------*/
  598.     /* Code Body                                                      */
  599.     /*----------------------------------------------------------------*/
  600.     if (g_nitz_cntx.Message != NULL)
  601.     {
  602.         OslMfree(g_nitz_cntx.Message);
  603.         g_nitz_cntx.Message = NULL;
  604.     }
  605. }
  608. /*****************************************************************************
  609.  * FUNCTION
  610.  *  NITZIgnore
  611.  * DESCRIPTION
  612.  *  RSK handler of NITZ screen.
  613.  * PARAMETERS
  614.  *  void
  615.  * RETURNS
  616.  *  void
  617.  *****************************************************************************/
  618. void NITZIgnore(void)
  619. {
  620.     /*----------------------------------------------------------------*/
  621.     /* Local Variables                                                */
  622.     /*----------------------------------------------------------------*/
  624.     /*----------------------------------------------------------------*/
  625.     /* Code Body                                                      */
  626.     /*----------------------------------------------------------------*/
  627.     g_nitz_cntx.IsNITZPending = FALSE;
  628.     GoBackHistory();
  629. }
  632. /*****************************************************************************
  633.  * FUNCTION
  634.  *  NITZAccept
  635.  * DESCRIPTION
  636.  *  This API calls on pressing OK on NITZ indication screen.
  637.  *  This API fills the time and date set screen and passes control to the same screen.
  638.  * PARAMETERS
  639.  *  void
  640.  * RETURNS
  641.  *  void
  642.  *****************************************************************************/
  643. void NITZAccept(void)
  644. {
  645.     /*----------------------------------------------------------------*/
  646.     /* Local Variables                                                */
  647.     /*----------------------------------------------------------------*/
  648.     MYTIME currTime;
  649.     MYTIME incTime;
  650.     nitz_nw_name_struct nw_name; 
  651.     S16 error;
  652. #ifdef __MMI_NITZ_TZ_SUPPORT__
  653.     MYTIME resultTime;
  654.     FLOAT nitz_tz, diff_tz;    
  655. #endif 
  657.     /*----------------------------------------------------------------*/
  658.     /* Code Body                                                      */
  659.     /*----------------------------------------------------------------*/
  660.     DTGetRTCTime(&currTime);
  661.     memset(&nw_name, 0, sizeof(nitz_nw_name_struct));
  663.     if (mmi_nitz_check_dt())
  664.     {
  665.         g_nitz_cntx.NITZTimeZone = nitzTempTZ;
  667.     memset(&incTime, 0, sizeof(MYTIME));
  668.     GetTimeDifference(&currTime, &g_nitz_cntx.RecvTime, &incTime);
  670.     IncrementTime(g_nitz_cntx.NITZTime, incTime, &(g_nitz_cntx.NITZTime));
  671.     #ifdef __MMI_NITZ_TZ_SUPPORT__
  672.         /* set time zone */
  673.         mmi_wc_set_home_city_from_nitz((S16) (g_nitz_cntx.NITZTimeZone - (g_nitz_cntx.NITZDST * 4)));
  674.         mmi_dt_set_dst((U8) g_nitz_cntx.NITZDST);
  675.     #endif /* __MMI_NITZ_TZ_SUPPORT__ */ 
  677.         SetProtocolEventHandler(mmi_nitz_time_res_rsp, HW_SET_TIME_REQ_SUCCESS);
  678.         mmi_dt_set_rtc_dt(&g_nitz_cntx.NITZTime);
  679.     }
  680. #ifdef __MMI_NITZ_TZ_SUPPORT__
  681.     else if (mmi_nitz_check_tz())
  682.     {
  683.         g_nitz_cntx.NITZTimeZone = nitzTempTZ;
  684.         g_nitz_cntx.NITZDST = nitzTempDST;
  685.         nitz_tz = (FLOAT) nitzTempTZ;
  686.         nitz_tz /= 4;
  688.         diff_tz = nitz_tz - GetTimeZone(PhnsetGetHomeCity());
  690.         /* turn DST off */
  691.         if (applib_dt_is_dst_enabled() == MMI_TRUE && g_nitz_cntx.NITZDST == 0)
  692.         {
  693.             diff_tz -= 1;
  694.         }
  695. #ifndef MMI_ON_WIN32
  696.         applib_dt_utc_to_rtc(diff_tz, (applib_time_struct*) & currTime, (applib_time_struct*) &resultTime);
  697. #else
  698. resultTime = mmi_dt_utc_to_rtc(diff_tz,  currTime);
  699. #endif        
  700.         memcpy(&(g_nitz_cntx.NITZTime), &resultTime, sizeof(MYTIME));
  702.         /* set time zone */
  703.         mmi_wc_set_home_city_from_nitz((S16) (g_nitz_cntx.NITZTimeZone - (g_nitz_cntx.NITZDST * 4)));
  704.         mmi_dt_set_dst((U8) g_nitz_cntx.NITZDST);
  705.         mmi_dt_set_rtc_dt(&g_nitz_cntx.NITZTime);
  706.     }
  707. #endif /* __MMI_NITZ_TZ_SUPPORT__ */ 
  708.     if (strlen((S8*) g_nitz_cntx.NWShortName) != 0)
  709.     {
  710.         memcpy(&(nw_name.plmn),gPLMN, MAX_PLMN_LEN_MMI);
  711.         memcpy(&(nw_name.name), &g_nitz_cntx.NWShortName, MAX_NW_LEN *ENCODING_LENGTH);
  712.         nw_name.add_ci = (U8) g_nitz_cntx.AddCI;
  713.         WriteRecord(NVRAM_EF_NITZ_NW_NAME_LID, 1, &nw_name, sizeof(nitz_nw_name_struct), &error);
  714.         
  715.         mmi_idle_update_opname_from_nitz();
  716.     }
  717.     else if (strlen((S8*) g_nitz_cntx.NWFullName) != 0)
  718.     {
  719.         memcpy(&(nw_name.plmn),gPLMN, MAX_PLMN_LEN_MMI);    
  720.         memcpy(&nw_name.name, &g_nitz_cntx.NWFullName, MAX_NW_LEN *ENCODING_LENGTH);
  721.         nw_name.add_ci = (U8) g_nitz_cntx.AddCI;
  722.         WriteRecord(NVRAM_EF_NITZ_NW_NAME_LID, 1, &nw_name, sizeof(nitz_nw_name_struct), &error);
  723.         
  724.         mmi_idle_update_opname_from_nitz();
  725.     }
  726.     else
  727.     {
  728.         memset(&(nw_name.plmn),0, MAX_PLMN_LEN_MMI);    
  729.         memset(&nw_name.name, 0, MAX_NW_LEN *ENCODING_LENGTH);
  730.         nw_name.add_ci = 0;
  731.         WriteRecord(NVRAM_EF_NITZ_NW_NAME_LID, 1, &nw_name, sizeof(nitz_nw_name_struct), &error);
  732.         
  733.         mmi_idle_update_opname_from_nitz();
  734.     }
  735.     g_nitz_cntx.IsNITZPending = FALSE;
  736. GoBackHistory();
  737. }
  739. /*****************************************************************************
  740.  * FUNCTION
  741.  *  mmi_nitz_get_nitz_nw_name
  742.  * DESCRIPTION
  743.  *  This API read nitz netowrk name information from NVRAM
  744.  * PARAMETERS
  745.  *  void
  746.  * RETURNS
  747.  *  void
  748.  *****************************************************************************/
  749. void mmi_nitz_get_nitz_nw_name(U8* plmn, U8* nwname, U8 len, BOOL* add_ci)
  750. {
  751.     nitz_nw_name_struct nw_name; 
  752.     S16 error;
  753.     
  754.     ReadRecord(NVRAM_EF_NITZ_NW_NAME_LID, 1, &nw_name, sizeof(nitz_nw_name_struct), &error);
  756.     if (plmn != NULL)
  757.     {
  758.         memcpy(plmn, nw_name.plmn, MAX_PLMN_LEN_MMI);
  759.     }
  761.     if (nwname != NULL)
  762.     {
  763. pfnUnicodeStrncpy((S8*) nwname, (S8*)nw_name.name, len);
  764.     }
  766.     if (add_ci != NULL)
  767.     {
  768.         memcpy(add_ci, &(nw_name.add_ci), sizeof(U8));    
  769.     }
  770. }
  772. /*****************************************************************************
  773.  * FUNCTION
  774.  *  mmi_nitz_check_dt
  775.  * DESCRIPTION
  776.  *  
  777.  *  This function is used to check if the date/time need to be updated from NITZ.
  778.  * PARAMETERS
  779.  *  void
  780.  * RETURNS
  781.  *  void
  782.  *****************************************************************************/
  783. U8 mmi_nitz_check_dt()
  784. {
  785.     /*----------------------------------------------------------------*/
  786.     /* Local Variables                                                */
  787.     /*----------------------------------------------------------------*/
  788.     MYTIME refTime1, refTime2, incTime;
  790.     /*----------------------------------------------------------------*/
  791.     /* Code Body                                                      */
  792.     /*----------------------------------------------------------------*/
  793.     memset(&incTime, 0, sizeof(MYTIME));
  794.     memset(&refTime1, 0, sizeof(MYTIME));
  795.     memset(&refTime2, 0, sizeof(MYTIME));
  797.     incTime.nMin = NITZ_MAX_ALLOW_DIFF;
  799.     IncrementTime(g_nitz_cntx.RecvTime, incTime, &refTime1);
  800.     DecrementTime(g_nitz_cntx.RecvTime, incTime, &refTime2);
  803.     if (!mmi_dt_is_valid(&g_nitz_cntx.NITZTime))
  804.         return MMI_FALSE;
  805. else if ((CompareTime(g_nitz_cntx.NITZTime, refTime1, NULL) == TIME_LESS) &&
  806.              (CompareTime(g_nitz_cntx.NITZTime, refTime2, NULL) == TIME_GREATER))
  807.         return MMI_FALSE;
  808. #ifdef __MMI_CHECK_DUPLICATED_NITZ__
  809.     else if (nitzTempTZ == g_nitz_cntx.NITZTimeZone)
  810.         return MMI_FALSE;
  811. #endif    
  812.     else
  813.         return MMI_TRUE;
  814. }
  815. #ifdef __MMI_NITZ_TZ_SUPPORT__
  818. /*****************************************************************************
  819.  * FUNCTION
  820.  *  mmi_nitz_check_tz
  821.  * DESCRIPTION
  822.  *  
  823.  * PARAMETERS
  824.  *  void
  825.  * RETURNS
  826.  *  
  827.  *****************************************************************************/
  828. U8 mmi_nitz_check_tz(void)
  829. {
  830.     /*----------------------------------------------------------------*/
  831.     /* Local Variables                                                */
  832.     /*----------------------------------------------------------------*/
  834.     /*----------------------------------------------------------------*/
  835.     /* Code Body                                                      */
  836.     /*----------------------------------------------------------------*/
  837.     /* Need to update time zone */
  838.     if (g_nitz_cntx.TimeZoneP == MMI_TRUE)
  839.     {
  840.         if (nitzTempTZ != g_nitz_cntx.NITZTimeZone || nitzTempDST != g_nitz_cntx.NITZDST)
  841.         {
  842.             return MMI_TRUE;
  843.         }
  844.     }
  845.     return MMI_FALSE;
  846. }
  847. #endif /* __MMI_NITZ_TZ_SUPPORT__ */ 
  849. /*****************************************************************************
  850.  * FUNCTION
  851.  *  NITZMessageString
  852.  * DESCRIPTION
  853.  *  Return the new time zone string, need to be display using in IDLE screen.
  854.  * PARAMETERS
  855.  *  void
  856.  * RETURNS
  857.  *  void
  858.  *****************************************************************************/
  859. S8 *NITZMessageString(void)
  860. {
  861.     /*----------------------------------------------------------------*/
  862.     /* Local Variables                                                */
  863.     /*----------------------------------------------------------------*/
  864.     S8 *tmpStr;
  866.     /*----------------------------------------------------------------*/
  867.     /* Code Body                                                      */
  868.     /*----------------------------------------------------------------*/
  869.     if (g_nitz_cntx.Message == NULL)
  870.     {
  871.         g_nitz_cntx.Message = OslMalloc(NITZ_NOTIFY_LENGTH);
  872.     }
  874.     tmpStr = GetString(NITZTIMECHANGESTR);
  876.     pfnUnicodeStrncpy((S8*) g_nitz_cntx.Message, tmpStr, pfnUnicodeStrlen((S8*) tmpStr));
  878.     return g_nitz_cntx.Message;
  879. }
  882. /*****************************************************************************
  883.  * FUNCTION
  884.  *  NITZTimeZoneString
  885.  * DESCRIPTION
  886.  *  
  887.  * PARAMETERS
  888.  *  timezone        [IN]        
  889.  *  string          [?]         
  890.  * RETURNS
  891.  *  void
  892.  *****************************************************************************/
  893. void NITZTimeZoneString(S16 timezone, S8 *string)
  894. {
  895.     /*----------------------------------------------------------------*/
  896.     /* Local Variables                                                */
  897.     /*----------------------------------------------------------------*/
  898.     S8 tmpBuff[NITZ_TIME_LEN];
  900.     /*----------------------------------------------------------------*/
  901.     /* Code Body                                                      */
  902.     /*----------------------------------------------------------------*/
  903.     if (timezone < 0)
  904.     {
  905.         timezone = 0 - timezone;
  906.         sprintf(tmpBuff, "-%02d:%02d", (timezone / 4), (timezone % 4) * 15);
  907.     }
  908.     else
  909.     {
  910.         sprintf(tmpBuff, "+%02d:%02d", (timezone / 4), (timezone % 4) * 15);
  911.     }
  913.     AnsiiToUnicodeString(string, tmpBuff);
  914. }
  917. /*****************************************************************************
  918.  * FUNCTION
  919.  *  NITZConvertTime
  920.  * DESCRIPTION
  921.  *  Utility function require by NITZ to convert BCD Date to decimal.
  922.  * PARAMETERS
  923.  *  time        [IN]        
  924.  * RETURNS
  925.  *  void
  926.  *****************************************************************************/
  927. U8 NITZConvertTime(U8 time)
  928. {
  929.     /*----------------------------------------------------------------*/
  930.     /* Local Variables                                                */
  931.     /*----------------------------------------------------------------*/
  932.     U8 tmp1 = 0, tmp2 = 0;
  934.     /*----------------------------------------------------------------*/
  935.     /* Code Body                                                      */
  936.     /*----------------------------------------------------------------*/
  937.     tmp1 = time & NITZ_HIGH_BIT;
  938.     tmp1 = tmp1 >> 4;
  939.     tmp2 = time & NITZ_LOW_BIT;
  940.     return tmp2 * 10 + tmp1;
  941. }
  944. /*****************************************************************************
  945.  * FUNCTION
  946.  *  NITZGetTimeZone
  947.  * DESCRIPTION
  948.  *  Utility function require by NITZ to convert BCD Date to decimal.
  949.  * PARAMETERS
  950.  *  t       [IN]        
  951.  * RETURNS
  952.  *  void
  953.  *****************************************************************************/
  954. S16 NITZGetTimeZone(U8 t)
  955. {
  956.     /*----------------------------------------------------------------*/
  957.     /* Local Variables                                                */
  958.     /*----------------------------------------------------------------*/
  959.     U8 tmp;
  960.     U8 NegFlag;
  961.     S16 result;
  962.     U8 timezone = t;
  964.     /*----------------------------------------------------------------*/
  965.     /* Code Body                                                      */
  966.     /*----------------------------------------------------------------*/
  967.     tmp = (t & NITZ_HIGH_BIT) >> 4;
  969.     if (t & NITZ_SIGN_BIT)  /* negative */
  970.     {
  971.         NegFlag = TRUE;
  972.     }
  973.     else    /* positive */
  974.     {
  975.         NegFlag = FALSE;
  976.     }
  978.     timezone &= NITZ_TZ_BIT;
  979.     timezone = timezone * 10 + tmp;
  981.     result = (S16) timezone;
  983.     if (NegFlag)
  984.     {
  985.         result = 0 - result;
  986.     }
  988.     return result;
  989. }
  991. /*****************************************************************************
  992.  * FUNCTION
  993.  *  mmi_nitz_time_res_rsp
  994.  * DESCRIPTION
  995.  *  Response of set RTC request.
  996.  * PARAMETERS
  997.  *  t       [IN]        
  998.  * RETURNS
  999.  *  void
  1000.  *****************************************************************************/   
  1001. void mmi_nitz_time_res_rsp(void *info)
  1002. {
  1003.     /*----------------------------------------------------------------*/
  1004.     /* Local Variables                                                */
  1005.     /*----------------------------------------------------------------*/
  1006.     RESULTSTRUCT *resp;
  1008.     /*----------------------------------------------------------------*/
  1009.     /* Code Body                                                      */
  1010.     /*----------------------------------------------------------------*/
  1011.     resp = (RESULTSTRUCT*) (info);
  1013.     if (resp->result == 1)
  1014.     {
  1015.     #ifdef __MTK_TARGET__
  1016.         gclockData.rtc_year = g_nitz_cntx.NITZTime.nYear- YEARFORMATE;
  1017.         gclockData.rtc_mon = g_nitz_cntx.NITZTime.nMonth;
  1018.         gclockData.rtc_day = g_nitz_cntx.NITZTime.nDay;
  1019.         gclockData.rtc_hour = g_nitz_cntx.NITZTime.nHour;
  1020.         gclockData.rtc_min = g_nitz_cntx.NITZTime.nMin;
  1021.         mmi_dt_check_rtc_time();
  1022.     #else /* __MTK_TARGET__ */ 
  1023.         MyTime.nHour = g_nitz_cntx.NITZTime.nHour;
  1024.         MyTime.nMin = g_nitz_cntx.NITZTime.nMin;
  1025.         MyTime.nYear = g_nitz_cntx.NITZTime.nYear;
  1026.         MyTime.nMonth = g_nitz_cntx.NITZTime.nMonth;
  1027.         MyTime.nDay = g_nitz_cntx.NITZTime.nDay;
  1028.         DateTimerProc();
  1029.     #endif /* __MTK_TARGET__ */ 
  1031.     
  1032.         update_mainlcd_dt_display();
  1033.         update_sublcd_dt_display();
  1035.         AlmReInitialize();
  1037.     }
  1038. }
  1041. #endif /* defined(__MMI_NITZ__) */ 
  1043. #endif /* _MMI_NITZ_C */ // #ifndef _MMI_NITZ_C