jvm_runtime.c

java 1.1 gemini 08_16

        }
        else
        {
            imsi_mcc[0] = jvm_imsi[1];
            imsi_mcc[1] = jvm_imsi[2];
            imsi_mcc[2] = jvm_imsi[3];
            imsi_mcc[3] = 0;
        }
    }

    return imsi_mcc;
}


/*****************************************************************************
 * FUNCTION
 *  jvm_get_imsi_mnc
 * DESCRIPTION
 *  get mnc of SIM card
 *  (Mobile Network Code, the 4-6 bytes of IMSI,
 *  BUT!, two bytes long in Europe, three bytes long in North America
 *  we cannot know how long it is here, we always return three bytes)
 * PARAMETERS
 *  void
 * RETURNS
 *  return NULL if fail
 *  return a uint8 array with size 3 back, caller should release
 *  this array by jvm_free
 *****************************************************************************/
kal_uint8 *jvm_get_imsi_mnc(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_uint8 *imsi_mnc = NULL;

    kal_uint32 event_group;

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

    kal_retrieve_eg_events(J2ME_general_event_group, J2ME_EG_GET_IMSI, KAL_OR_CONSUME, &event_group, KAL_SUSPEND);

    if (jvm_imsi_error != J2ME_NO_ERROR)
    {

        imsi_mnc = NULL;
    }
    else
    {

        imsi_mnc = jvm_malloc(4);
        if (jvm_imsi[4] == '0')
        {
            imsi_mnc[0] = jvm_imsi[5];
            imsi_mnc[1] = 0;
        }
        else
        {
            imsi_mnc[0] = jvm_imsi[4];
            imsi_mnc[1] = jvm_imsi[5];
            imsi_mnc[2] = 0;
        }
    }

    return imsi_mnc;
}


/*****************************************************************************
 * FUNCTION
 *  jvm_get_ext_queue_info
 * DESCRIPTION
 *  This routine implements to get external queue's information
 * PARAMETERS
 *  messages        [?]     -  Pointer to number of queue's messages
 * RETURNS
 *  KAL_TRUE if success, else fail
 *****************************************************************************/
kal_bool jvm_get_ext_queue_info(kal_uint32 *messages)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_bool retval;
    kal_msgq_info msgq_info;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    retval = kal_get_queue_info(task_info_g[INDX_J2ME].task_ext_qid, &msgq_info);

    if (retval == KAL_TRUE)
    {
        *messages = msgq_info.pending_msgs;
    }

    return retval;
}

volatile int jvm_timer_mutex_cnt = 0;
volatile module_type jvm_timer_mutex_tid = MOD_NIL;


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

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    /* GDI_LOCK; */
    if (stack_int_get_active_module_id() != jvm_timer_mutex_tid)
    {
        kal_take_mutex(J2ME_timer_mutex);
        jvm_timer_mutex_tid = stack_int_get_active_module_id();
    }
    ++jvm_timer_mutex_cnt;

}


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

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    ASSERT(jvm_timer_mutex_tid == stack_int_get_active_module_id());

    --jvm_timer_mutex_cnt;

    if (jvm_timer_mutex_cnt == 0)
    {
        jvm_timer_mutex_tid = MOD_NIL;
        kal_give_mutex(J2ME_timer_mutex);
    }
    /* GDI_UNLOCK; */
}


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

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    memset(jvm_timer_table, 0, sizeof(jvm_timer_table_struct) * MAX_NUM_OF_JVM_TIMER);
}


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

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    stack_start_timer((stack_timer_struct*) base_timer_ptr, JVM_BASE_TIMER_ID, time_out);
    return;
}


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

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    stack_stop_timer((stack_timer_struct*) base_timer_ptr);
    return;
}


/*****************************************************************************
 * FUNCTION
 *  jvm_timer_expiry_callback
 * DESCRIPTION
 *  
 * PARAMETERS
 *  arg     [?] 
 * RETURNS
 *  void
 *****************************************************************************/
void jvm_timer_expiry_callback(void *arg)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_uint8 *timer_id = (kal_uint8*) arg;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_FUNC, FUNC_J2ME_JVM_TIMER_EXPIRY_CALLBACK, timer_id);

    jvm_timer_mutex_lock();
    if ((kal_uint32) timer_id < (kal_uint32) MAX_NUM_OF_JVM_TIMER)
    {
        jvm_timer_table[(kal_uint32) (timer_id)].event_id = NULL;
        (jvm_timer_table[(kal_uint32) (timer_id)].callback_func) (jvm_timer_table[(kal_uint32) (timer_id)].arg);
    }
    jvm_timer_mutex_unlock();
}


/*****************************************************************************
 * FUNCTION
 *  jvm_start_timer
 * DESCRIPTION
 *  
 * PARAMETERS
 *  period              [IN]        
 *  timer_expiry        [IN]        
 *  arg                 [?] 
 * RETURNS
 *  void
 *****************************************************************************/
kal_int32 jvm_start_timer(kal_uint32 period, kal_timer_func_ptr timer_expiry, void *arg)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_uint16 temp = (period * 7) >> 5;    /* ~= x 1/4.615 */
    kal_int32 i, timer_id = -1;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    jvm_timer_mutex_lock();
    /* Search for free timer */
    for (i = 0; i < MAX_NUM_OF_JVM_TIMER; i++)
    {
        if (jvm_timer_table[i].event_id == NULL)
        {
            timer_id = i;
            break;
        }
    }

    /* No free timer */
    if (timer_id == -1)
    {
        jvm_timer_mutex_unlock();
        return -1;
    }

    kal_trace(TRACE_FUNC, FUNC_J2ME_JVM_START_TIMER, timer_id, period);

    if (temp == 0)
    {
        temp = 1;
    }
    jvm_timer_table[timer_id].callback_func = timer_expiry;
    jvm_timer_table[timer_id].arg = arg;
    jvm_timer_table[timer_id].event_id = evshed_set_event(
                                            jvm_event_scheduler_ptr,
                                            (kal_timer_func_ptr) jvm_timer_expiry_callback,
                                            (void*)timer_id,
                                            temp);
    jvm_timer_mutex_unlock();
    return timer_id;
}


/*****************************************************************************
 * FUNCTION
 *  jvm_stop_timer
 * DESCRIPTION
 *  
 * PARAMETERS
 *  timer_id        [IN]        
 * RETURNS
 *  void
 *****************************************************************************/
void jvm_stop_timer(kal_int32 timer_id)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_FUNC, FUNC_J2ME_JVM_STOP_TIMER, timer_id);

    jvm_timer_mutex_lock();
    
    if (jvm_timer_table[timer_id].event_id != NULL)
    {
        evshed_cancel_event(jvm_event_scheduler_ptr, &(jvm_timer_table[timer_id].event_id));
        jvm_timer_table[timer_id].event_id = NULL;
    }
    jvm_timer_mutex_unlock();
}


/*****************************************************************************
 * FUNCTION
 *  jvm_stop_all_timer
 * DESCRIPTION
 *  
 * PARAMETERS
 *     
 * RETURNS
 *  void
 *****************************************************************************/
void jvm_stop_all_timer(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_int32 timer_id;

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

    jvm_timer_mutex_lock();
    /* Search for free timer */
    for (timer_id = 0; timer_id < MAX_NUM_OF_JVM_TIMER; timer_id++)
    {
        jvm_stop_timer(timer_id);
    }
    jvm_timer_mutex_unlock();
}