idleapp.c

MTK平台QQ移植

        
        if (mmi_ucs2strlen((S8*) tmp_display_name) >= max_display_length)
        {
            mmi_ucs2ncpy((S8*) g_nitz_display_2.display_name, (S8*) tmp_display_name, max_display_length);
        }
        else
        {
            mmi_ucs2cpy((S8*) g_nitz_display_2.display_name, (S8*) tmp_display_name);
        }

        /* add check if the NITZ display name exceeds the LCD width */
        memcpy(&prev_f, UI_font, sizeof(stFontAttribute));
        UI_set_font(&UI_DEFAULT_FONT);
        for (iCnt = (U8) mmi_ucs2strlen((PS8) g_nitz_display_2.display_name); iCnt > 0; iCnt--)
        {
            Get_StringWidthHeight((U8*) g_nitz_display_2.display_name, &StringWidth, &StringHeight);
            if ((StringWidth + 1) >= MAIN_LCD_device_width - (MMI_IDLE_STRING_MARGIN_GAP << 1))
            {
                g_nitz_display_2.display_name[iCnt * ENCODING_LENGTH] = 0x0;
                g_nitz_display_2.display_name[iCnt * ENCODING_LENGTH + 1] = 0x0;
            }
            else
            {
                break;
            }
        }
        UI_set_font(&prev_f);

        if (g_nitz_display_2.country_init)
        {
            mmi_asc_n_to_ucs2((S8*) mcc_tmp_unicode, (S8*) g_nitz_display_2.plmn, 3);
            mmi_ucs2cat((S8*) g_nitz_display_2.display_name, " ");
            mmi_ucs2cat((S8*) g_nitz_display_2.display_name, (S8*) mcc_tmp_unicode);
        }

        g_nitz_display_2.opname_from_nitz = 1;
    }
    else
    {
        g_nitz_display_2.opname_from_nitz = 0;
    }
}


/*****************************************************************************
 * FUNCTION
 *  mmi_idle_check_sim2_nitz_display_validation
 * DESCRIPTION
 *  
 * PARAMETERS
 *  void
 * RETURNS
 *  
 *****************************************************************************/
pBOOL mmi_idle_check_sim2_nitz_display_validation(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (memcmp(g_nitz_display_2.plmn, gPLMN_2, MAX_PLMN_LEN_MMI) != 0)
    {
        g_nitz_display_2.opname_from_nitz = 0;
        return MMI_FALSE;
    }
    else
    {
        return MMI_TRUE;
    }
}
#endif /* __MMI_DUAL_SIM_MASTER__ */

#endif /* __MMI_NITZ__ */ 


/*****************************************************************************
 * FUNCTION
 *  mmi_idle_widget_check_and_display_new_msg
 * DESCRIPTION
 *  Wrapper for idle screen callback
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
#if defined(OBIGO_Q03C) && defined(WAP_SUPPORT)
static U8 mmi_idle_widget_check_and_display_new_msg(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    /* Check WNOTI_CTX->check_msg_in_idle_screen first */
    widget_check_msg_in_idle_screen();
    if (g_keylock_context.gKeyPadLockFlag)
    {
        if (widget_MMI_check_and_display_new_msg_when_keypad_lock
            (g_keylock_context.KeyLockLSKStringID, g_keylock_context.KeyLockLSKIconID,
             g_keylock_context.KeyLockRSKStringID, g_keylock_context.KeyLockRSKIconID))
        {
            /* Check WNOTI_CTX->check_msg_in_idle_screen again */
            widget_check_msg_in_idle_screen();
            return MMI_TRUE;
        }
    }
    else
    {
        if (widget_MMI_check_and_display_new_msg())
        {
            /* Check WNOTI_CTX->check_msg_in_idle_screen again */
            widget_check_msg_in_idle_screen();
            return MMI_TRUE;
        }
    }
    return MMI_FALSE;
}
#endif /* defined(OBIGO_Q03C) && defined(WAP_SUPPORT) && !defined (__UNIFIED_MSG_SUPPORT__) */ 


/*****************************************************************************
 * FUNCTION
 *  mmi_idle_pen_block
 * DESCRIPTION
 *  
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
#ifdef __MMI_TOUCH_SCREEN__
void mmi_idle_pen_block(void)
{
#ifndef __MMI_GPIO_DISABLE_SLEEP_MODE__
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    extern BOOL gIsInSleepMode;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (gIsInSleepMode != 1)
#endif /* __MMI_GPIO_DISABLE_SLEEP_MODE__ */ 
        mmi_pen_block();
}
#endif /* __MMI_TOUCH_SCREEN__ */

/*****************************************************************************
 * FUNCTION
 *  mmi_idle_set_keypad_lock_string
 * DESCRIPTION
 *  This function is used to set keypad lock RSK string
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
void mmi_idle_set_keypad_lock_string(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    g_keylock_context.KeyLockRSKStringID = 0;
    g_keylock_context.KeyLockRSKIconID = 0;
    g_keylock_context.KeyLockLSKStringID = 0;
    g_keylock_context.KeyLockLSKIconID = 0;

    if (g_idle_context.IsOnIdleScreen == 1 || g_idle_context.IsOnSimErrorScreen == 1)
    {
    #ifdef __MMI_TOUCH_SCREEN__
        ChangeStatusIconImage(STATUS_ICON_KEYPAD_LOCK, IMG_SI_KEYPAD_LOCK);
    #else 
        ShowStatusIcon(STATUS_ICON_KEYPAD_LOCK);
    #endif 

    #ifdef __MMI_KEYPAD_LOCK_PATTERN_1__
    #ifdef __MMI_TOUCH_SCREEN__
        g_keylock_context.KeyLockRSKStringID = SCREEN_LOCKED_TEXT;
    #else 
        g_keylock_context.KeyLockRSKStringID = KEYPAD_LOCKED_RSK_TEXT;
    #endif 
    #endif /* __MMI_KEYPAD_LOCK_PATTERN_1__ */ 

    #ifdef __MMI_KEYPAD_LOCK_PATTERN_2__
    #ifdef __MMI_TOUCH_SCREEN__
        g_keylock_context.KeyLockLSKStringID = SCREEN_LOCKED_TEXT;
    #else 
        g_keylock_context.KeyLockLSKStringID = KEYPAD_LOCKED_RSK_TEXT;
    #endif 
    #endif /* __MMI_KEYPAD_LOCK_PATTERN_2__ */ 
    }
    else
    {
        /* If active screen is not idle, pen is not blocked */
        /* Set RSK/LSK string to "unlock" because it is allowed to click the touch screen to unlock */
    #ifdef __MMI_KEYPAD_LOCK_PATTERN_1__
        g_keylock_context.KeyLockRSKStringID = KEYPAD_LOCKED_RSK_TEXT;
    #endif 
    #ifdef __MMI_KEYPAD_LOCK_PATTERN_2__
        g_keylock_context.KeyLockLSKStringID = KEYPAD_LOCKED_RSK_TEXT;
    #endif 
    }
}


/*****************************************************************************
 * FUNCTION
 *  mmi_idle_dummy_key_handler
 * DESCRIPTION
 *  This function is a dummy handler for idle screen keys
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
static FuncPtr dummyKeyHandler[MAX_KEYS];
extern FuncPtr currKeyFuncPtrs[MAX_KEYS][MAX_KEY_TYPE];

void mmi_idle_dummy_key_handler(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    U8 ScreenSaverStatus, ScreenSaverWait;
    U16 keyCode, keyType;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    PhnsetGetScrSvrSetings(&ScreenSaverStatus, &ScreenSaverWait);

    GetkeyInfo(&keyCode, &keyType);

    if (g_idle_context.IsOnIdleScreen)
    {
        /* postpone the screensaver after press keys */
        if (dummyKeyHandler[keyCode] != NULL && !g_keylock_context.gKeyPadLockFlag)
        {
            (*dummyKeyHandler[keyCode]) ();
        }

        if (keyCode == KEY_ENTER && !g_keylock_context.gKeyPadLockFlag)
        {
            ClearKeyHandler(KEY_ENTER, KEY_EVENT_DOWN);
        }
    }

    if (g_idle_context.IsOnIdleScreen)
    {
        StopTimer(SCREENSAVER_TIMER);
        StartTimer(SCREENSAVER_TIMER, ScreenSaverWait * 1000, EntryIdleSetScreenSaver);
    }
}


/*****************************************************************************
 * FUNCTION
 *  mmi_idle_date_time_reminder
 * DESCRIPTION
 *  
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
static void mmi_idle_date_time_reminder(void)
{
#if defined(__MMI_DATE_TIME_SETTING_REMINDER__)
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    static BOOL datejust_reminder_shown = MMI_FALSE;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (!datejust_reminder_shown && RTC_is_MS_FirstPowerOn())
    {
        DisplayPopup((PU8) GetString(STR_DATE_TIME_UPDATE_REMINDER), IMG_GLOBAL_OK, 0, 2000, 0);
        datejust_reminder_shown = MMI_TRUE;
    }
#endif /* defined(__MMI_DATE_TIME_SETTING_REMINDER__) */ 
}


/*****************************************************************************
 * FUNCTION
 *  mmi_idle_dummy_key_in_screensaver
 * DESCRIPTION
 *  
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
static void mmi_idle_dummy_key_in_screensaver(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    U8 i;
    U8 ScreenSaverStatus, ScreenSaverWait;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (IsClamClose())
    {
        return ;
    }

    PhnsetGetScrSvrSetings(&ScreenSaverStatus, &ScreenSaverWait);
    /* Compensatory key handler registration for screen saver.             */
    /* The idea here is to set those keys which are not set with handlers to a dummy handler. */
    /* But not that END key is still being set a handler (DisplayIdleScreen)        */
    /* for KEY_EVENT_DOWN in PowerAndEndKeyHandler.                  */
    if (g_keylock_context.gKeyPadLockFlag)
    {
        if (ScreenSaverStatus == 1) /* Screensaver is set to on */
        {
            for (i = KEY_0; i < MAX_KEYS; i++)
            {
                if ((GetKeyHandler(i, KEY_EVENT_DOWN) == NULL) && (GetKeyHandler(i, KEY_EVENT_UP) == NULL))
                {
                    SetKeyHandler(mmi_idle_dummy_key_handler, i, KEY_EVENT_DOWN);
                }
            }
            /*  add this because of PowerAndEndKeyHandler */
        #ifndef __MMI_KEYPAD_LOCK_PROMPT_TEXT__
            /* diamond, 2005/12/20 END key is registered to prompt text if __MMI_KEYPAD_LOCK_PROMPT_TEXT__ is on */
            SetKeyHandler(mmi_idle_dummy_key_handler, KEY_END, KEY_EVENT_DOWN);
        #endif /* __MMI_KEYPAD_LOCK_PROMPT_TEXT__ */ 
        }
    }
    else
    {
        if (ScreenSaverStatus == 1) /* Screensaver is set to on */
        {
            for (i = KEY_0; i < MAX_KEYS; i++)
            {
                if (i == KEY_ENTER && GetKeyHandler(i, KEY_EVENT_UP) == NULL && GetKeyHandler(i, KEY_EVENT_DOWN) == NULL && GetKeyHandler(i, KEY_LONG_PRESS) == NULL)
                {
                #ifndef __MMI_TOUCH_IDLESCREEN_SHORTCUTS__
                    dummyKeyHandler[i] = dummyKeyHandler[KEY_LSK];
                    SetKeyHandler(mmi_idle_dummy_key_handler, i, KEY_EVENT_DOWN);
                #endif
                    continue;
                }
                dummyKeyHandler[i] = GetKeyHandler(i, KEY_EVENT_DOWN);
                SetKeyHandler(mmi_idle_dummy_key_handler, i, KEY_EVENT_DOWN);
            }
        }
    }
}


/*****************************************************************************
 * FUNCTION
 *  mmi_idle_set_eg_events
 * DESCRIPTION
 *  
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
extern void nor_sweep_device(void);

static void mmi_idle_set_eg_events(void)
{
#ifdef __MTK_TARGET__
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    pBOOL egIsSet = 0;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (!egIsSet)
    {
        nor_sweep_device();
        egIsSet = 1;
    }
#endif /* __MTK_TARGET__ */
}


/*****************************************************************************
 * FUNCTION
 *  mmi_idle_start_keypad_lock
 * DESCRIPTION
 *  
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
void mmi_idle_start_keypad_lock(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    mmi_idle_set_eg_events();

    if (!g_keylock_context.gKeyPadLockFlag) /* keypad isn't lock now */
    {
        SETTING_AKPL_TIME GetAutoLockTimeOut = GetAutoKeypadLockTime();

        switch (GetAutoLockTimeOut)
        {
            case TIME_0:
                g_idle_context.AutoLockTimeOut = 0;
                break;
            case TIME_5:
                g_idle_context.AutoLockTimeOut = 5000;
                break;
            case TIME_30:
                g_idle_context.AutoLockTimeOut = 30000;
                break;
            case TIME_60:
                g_idle_context.AutoLockTimeOut = 60000;
                break;
            case TIME_2:
                g_idle_context.AutoLockTimeOut = 300000;
                break;
        }

        if (g_idle_context.AutoLockTimeOut != 0)
        {
            PRINT_INFORMATION("[Keypad Lock] mmi_idle_start_keypad_lock: Timer %d start", g_idle_context.AutoLockTimeOut);
            if (mmi_idle_is_on_idle_screen())
            {
                StartTimer(IDLE_APP_AUTO_LOCK_TIMER_ID, g_idle_context.AutoLockTimeOut, IdleSetKeyPadLockFlag);
            }
            else
            {
                StartTimer(IDLE_APP_AUTO_LOCK_TIMER_ID, g_idle_context.AutoLockTimeOut, InsertSimSetKeyPadLockFlag);
            }
        }
    }
}


/*****************************************************************************
 * FUNCTION
 *  mmi_idle_restart_keypad_lock_timer
 * DESCRIPTION
 *  
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
void mmi_idle_restart_keypad_lock_timer(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (g_keylock_context.gKeyPadLockFlag == 1)
    {
        return;
    }

    if (g_idle_context.AutoLockTimeOut != 0 &&
        (g_idle_context.IsOnIdleScreen == 1 || g_idle_context.IsOnSimErrorScreen == 1))
    {
        StopTimer(IDLE_APP_AUTO_LOCK_TIMER_ID);
        if (g_idle_context.IsOnIdleScreen == 1)
        {
            StartTimer(IDLE_APP_AUTO_LOCK_TIMER_ID, g_idle_context.AutoLockTimeOut, IdleSetKeyPadLockFlag);
        }
        if (g_idle_context.IsOnSimErrorScreen == 1)
        {
            StartTimer(IDLE_APP_AUTO_LOCK_TIMER_ID, g_idle_context.AutoLockTimeOut, InsertSimSetKeyPadLockFlag);
        }
    }
}


/*****************************************************************************
 * FUNCTION
 *  mmi_idle_start_screensaver
 * DESCRIPTION
 *  
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
void mmi_idle_start_screensaver(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    U8 ScreenSaverStatus, ScreenSaverWait;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    PhnsetGetScrSvrSetings(&ScreenSaverStatus, &ScreenSaverWait);

    if (ScreenSaverStatus == 0xFF)
    {
        PhnsetRstScrSvrDefault();
    }

    if (ScreenSaverStatus == 1) /* Screensaver is set to on */
    {
        StartTimer(SCREENSAVER_TIMER, ScreenSaverWait * 1000, EntryIdleSetScreenSaver);
    }
}


/*****************************************************************************
 * FUNCTION
 *  mmi_idle_restart_screensaver_timer
 * DESCRIPTION
 *  
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
void mmi_idle_restart_screensaver_timer(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    U8 ScreenSaverStatus, ScreenSaverWait;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (g_idle_context.ScreenSaverRunFlag == 1) /* screensaver is running */
    {
        return;
    }

    if (g_idle_context.IsOnIdleScreen == 1)
    {
        PhnsetGetScrSvrSetings(&ScreenSaverStatus, &ScreenSaverWait);
        if (ScreenSaverStatus == 0xFF)
        {
            PhnsetRstScrSvrDefault();
        }

        if (ScreenSaverStatus == 1) /* screensaver is active */
        {
            StopTimer(SCREENSAVER_TIMER);
            StartTimer(SCREENSAVER_TIMER, ScreenSaverWait * 1000, EntryIdleSetScreenSaver);
        }