jpush_timealarm.c

java 1.1 gemini 08_16

 * FUNCTION
 *  jpush_alarm_cancel
 * DESCRIPTION
 *  cancel the alarm registrations from event schedule
 * PARAMETERS
 *  event_id        [?]  
 * RETURNS
 *  void
 *****************************************************************************/
void jpush_alarm_cancel(eventid *event_id)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_FUNC, JPUSH_ALARM_CANCEL);     
    if(*event_id){
        evshed_cancel_event(j2me_alarm_es_ptr, event_id);
    }
}


/*****************************************************************************
 * FUNCTION
 *  jpush_alarm_check
 * DESCRIPTION
 *  
 * PARAMETERS
 *  time        [IN]        
 * RETURNS
 *  void
 *****************************************************************************/
kal_int64 jpush_alarm_check(kal_int64 time)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    alarmentry_struct *alarmp;
    alarmentry_struct *alarmnext;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_FUNC, JPUSH_ALARM_CHECK);      
    /* Find any alarm that has expired. */
    for (alarmp = g_jpush_alarmlist_ptr; alarmp != NULL; alarmp = alarmnext)
    {
        alarmnext = alarmp->next;

        if (alarmp->executed == 1)
        {
            continue;
        }

        if ((time - alarmp->wakeup) > 0)
        {
            return alarmp->wakeup;
        }
    }


    return (-1);
}


/*****************************************************************************
 * FUNCTION
 *  j2me_alarm_start_timer
 * DESCRIPTION
 *  
 * PARAMETERS
 *  base_timer_ptr      [?]    
 *  time_out            [IN]        
 * RETURNS
 *  void
 *****************************************************************************/
void j2me_alarm_start_timer(void *base_timer_ptr, kal_uint32 time_out)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_FUNC, JPUSH_ALARM_START_TIMER);     
    stack_start_timer((stack_timer_struct*) base_timer_ptr, 0, time_out);
    return;
}


/*****************************************************************************
 * FUNCTION
 *  j2me_alarm_stop_timer
 * DESCRIPTION
 *  
 * PARAMETERS
 *  base_timer_ptr      [?]  
 * RETURNS
 *  void
 *****************************************************************************/
void j2me_alarm_stop_timer(void *base_timer_ptr)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_FUNC, JPUSH_ALARM_STOP_TIMER);     
    stack_stop_timer((stack_timer_struct*) base_timer_ptr);
    return;
}


/*****************************************************************************
 * FUNCTION
 *  j2me_alarm_timeout_handler
 * DESCRIPTION
 *  
 * PARAMETERS
 *  param_ptr       [?]   
 * RETURNS
 *  void
 *****************************************************************************/
void j2me_alarm_timeout_handler(void *param_ptr)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    alarmentry_struct *entry_ptr = param_ptr;
    alarmentry_struct *alarmp;
    alarmentry_struct *alarmnext;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    /* timealarm */
    kal_trace(TRACE_FUNC, JPUSH_ALARM_TIMEOUT_HDR);  

    for (alarmp = g_jpush_alarmlist_ptr; alarmp != NULL; alarmp = alarmnext)
    {
        if (alarmp == entry_ptr)
        {
            break;
        }
        alarmnext = alarmp->next;
    }
    /* the timer alarm entry has been removed, do not thing. */
    if (alarmp != entry_ptr)
    {
        return;
    }
    /* Fix to remove event id immediately, instead MMI response. */
    entry_ptr->event_id = NULL;

    /* the following two functions invoke IO. */
    /* set event id is NULL must be done firstly or it may cause the "cancel another guy's event" */
    jpush_alarm_del_file(entry_ptr);

    java_mmi_timealarm_push_ind_handler(
        entry_ptr->alarm_game_type,
        PUSHTYPE_ALARM_PUSH,
        (void*)entry_ptr,
        entry_ptr->midlet,
        entry_ptr->storagename);
}

#if PERSISTENT_ALARMPUSH


/*****************************************************************************
 * FUNCTION
 *  jpush_alarm_free
 * DESCRIPTION
 *  
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
void jpush_alarm_free()
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    alarmentry_struct *alarmp, *alarmtmp;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    /* clean up the list */
    for (alarmp = g_jpush_alarmlist_ptr; alarmp != NULL; alarmp = alarmtmp)
    {
        alarmtmp = alarmp->next;
        free_ctrl_buffer(alarmp->midlet);
        free_ctrl_buffer(alarmp->storagename);
        free_ctrl_buffer(alarmp);
    }
}


/*****************************************************************************
 * FUNCTION
 *  jpush_alarm_parse
 * DESCRIPTION
 *  Parse the persistent alaram registry from disk into the
 *  in memory cache representation.
 * PARAMETERS
 *  pushfd      [IN]        
 * RETURNS
 *  void
 *****************************************************************************/
int jpush_alarm_parse(kal_int32 pushfd)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    char buffer[MAX_PUSH_LINE + 1];
    char tmp_buf[25]; //maximun for 64bits  wake up time
    kal_bool eof = KAL_FALSE;
    int i;
    alarmentry_struct *pe;
    kal_char *tmp_str;
    kal_int32 tmp_len = 0;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_FUNC, JPUSH_ALARM_PARSE); 

    while (eof == KAL_FALSE)
    {
        /* Read a line at a time */
        for (i = 0; i < MAX_PUSH_LINE; i++)
        {
            tmp_len = jvm_file_read(pushfd, &buffer[i], 1);

            /* EOF */
            if (tmp_len == 0)
            {
                eof = KAL_TRUE;
                break;
            }

            /* EOL */
            if ((buffer[i] == '\n') || (i == MAX_PUSH_LINE))
            {
                buffer[i] = 0;
                break;
            }
            /* Ignore carriage returns */
            if (buffer[i] == '\r')
            {
                i--;
            }
        }

        /* Skip comment lines which begin  with '#' */
        if (eof == KAL_FALSE && buffer[0] != '#')
        {
            if ((pe = (alarmentry_struct*) get_ctrl_buffer(sizeof(alarmentry_struct))) != NULL)
            {
                kal_trace(TRACE_FUNC, JPUSH_ALARM_PARSE_START);             
                
                pe->next = g_jpush_alarmlist_ptr;

                tmp_str = jpush_push_getstoragename(buffer, 0, &tmp_len);
                kal_mem_cpy(tmp_buf, tmp_str, tmp_len);
                tmp_buf[tmp_len] = 0;                 
                pe->executed = atoi(tmp_str);

                tmp_str = jpush_push_getstoragename(buffer, 1, &tmp_len);
                pe->midlet = jvm_str_dup(tmp_str, tmp_len);
                Kputs(pe->midlet); 

                tmp_str = jpush_push_getstoragename(buffer, 2, &tmp_len);
                kal_mem_cpy(tmp_buf, tmp_str, tmp_len);
                tmp_buf[tmp_len] = 0;
                sscanf(tmp_buf, "%lld", &(pe->wakeup));
                Kputs(tmp_buf); 

                tmp_str = jpush_push_getstoragename(buffer, 3, &tmp_len);
                pe->storagename = jvm_str_dup(tmp_str, tmp_len);

                tmp_str = jpush_push_getstoragename(buffer, 4, &tmp_len);
                kal_mem_cpy(tmp_buf, tmp_str, tmp_len);
                tmp_buf[tmp_len] = 0;
                pe->alarm_game_type = atoi(tmp_buf);
                
                kal_trace(TRACE_FUNC, JPUSH_ALARM_PARSE_END); 

                /* for fix the issue : the store data is incorrect due to unknown reason */
                if ((pe->midlet == NULL) || 
                    (pe->storagename == NULL) || 
                    (pe->wakeup < 0) || 
                    (pe->alarm_game_type >= GAMETYPE_INVALID_TYPE) || 
                    (pe->executed < 0))
                {
                    if (pe->midlet)
                    {
                        free_ctrl_buffer(pe->midlet);
                    }
                    if (pe->storagename)
                    {
                        free_ctrl_buffer(pe->storagename);
                    }
                    g_jpush_alarmlist_ptr = pe->next;
                    free_ctrl_buffer(pe);
                    pe = NULL;
                    
                    kal_trace(TRACE_FUNC, JPUSH_ALARM_PARSE_ERROR_AND_DROP);                     
                    
                }
                else
                {
                    kal_uint32 alarm_period;

                    g_jpush_alarmlist_ptr = pe;

                    if ((pe->wakeup) >= CurrentTime_md())
                    {

                        /* Set timer */
                        alarm_period = j2me_ms_2_tick(pe->wakeup - CurrentTime_md());
                        kal_trace(TRACE_FUNC, JPUSH_ALARM_PARSE_A_NON_TIMEOUT_PUSH,alarm_period);                         

                        /* for debug : print the timeout tick */
                        {
                            char ss[100]="";
                            sprintf(ss,"%u",alarm_period);
                            Kputs(ss);
                        }
                        
                        pe->event_id = jpush_alarm_set(pe, alarm_period);
                    }
                    else
                    {
                        kal_trace(TRACE_FUNC, JPUSH_ALARM_PARSE_A_TIMEOUT_PUSH);      
                        
                        /*for fix the issue : the timeouthandler is too fast to interrupt the parse */
                        /*                    because the Aplix CurrentTime_md() will process timeout msg */
                        pe->event_id = jpush_alarm_set(pe, 2500);
                    }

                }
            }
            else
            {
                /* alarmListFree(); */
                return -2;
            }
        }
    }

    return 0;
}
#endif /* PERSISTENT_ALARMPUSH */