jwa_sms.c

java 1.1 gemini 08_16

}


/*****************************************************************************
 * FUNCTION
 *  J2ME_sms_response_handler
 * DESCRIPTION
 *  
 * PARAMETERS
 *  ilm_ptr     [?]     
 * RETURNS
 *  void
 *****************************************************************************/
void J2ME_sms_response_handler(ilm_struct *ilm_ptr)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (J2ME_async_sms_msgid && flag_wait_async_sms_msgid)
    {
        /* Pedning async event */
        kal_uint32 event_group, polling = 0;
        kal_status result;

        while (1)
        {
            /* 2nd bit indicate wait pending async event consumed */
            result = kal_retrieve_eg_events(J2ME_async_sms_eventgroup, 0x2, KAL_OR_CONSUME, &event_group, KAL_NO_SUSPEND);

            if (result != KAL_NOT_PRESENT || polling++ >= 100)
            {
                break;
            }
            /* To avoid deadlock and complicated timer control, use polling */
            kal_sleep_task(1);
        }
    }

    J2ME_async_sms_msgid = ilm_ptr->msg_id;
    
	switch (ilm_ptr->msg_id)
    {
        case MSG_ID_MMIAPI_SMS_REGISTER_PORT_RSP:
        {
            mmiapi_sms_register_port_rsp_struct *p = (mmiapi_sms_register_port_rsp_struct*) ilm_ptr->local_para_ptr;

            if (j2me_sms_register_type == WMA_REGISTRY)
            {
                J2ME_sms_save_result(MSG_J2ME_SMS_REGISTER_PORT_RSP, (int)p->result);
            }

            /* Register */
            if (j2me_sms_register_enable == KAL_TRUE)
            {

                if ((j2me_sms_register_type == WMA_REGISTRY) && p->result)
                {
                    int res = 0;
                    
                    /* register success, and we should unregister port when VM shutdown */
                    res = resouceRegistering(
                            JAVA_WMA_SMS_DEVICE,
                            (int)j2me_sms_register_port,
                            NULL,
                            NULL,
                            J2ME_sms_unregister_by_resource_manager);

                    /* If registering resource fails, deregister to native SMS module and report error to Java layer. */
                    if (res == RESOUCE_FAIL)
                    {
                        J2ME_sms_unregister_by_resource_manager(j2me_sms_register_port);
                        J2ME_sms_save_result(MSG_J2ME_SMS_REGISTER_PORT_RSP, (int)(KAL_FALSE));
                    }
                }
                j2me_sms_register_enable = KAL_FALSE;
                j2me_sms_register_port = -1;
            }
            /* Unregister  */
            else
            {

            }
            j2me_sms_register_type = -1;
        }
            break;

        case MSG_ID_MMIAPI_SMS_SEND_RSP:
        {
            mmiapi_sms_send_rsp_struct *p = (mmiapi_sms_send_rsp_struct*) ilm_ptr->local_para_ptr;

            J2ME_sms_save_result(MSG_J2ME_SMS_SEND_RSP, (int)p->result);
        }
            break;

        case MSG_ID_MMIAPI_SMS_CHECK_INCOMING_MSG_RSP:
        {
            mmiapi_sms_check_incoming_msg_rsp_struct *p =
                (mmiapi_sms_check_incoming_msg_rsp_struct*) ilm_ptr->local_para_ptr;

            J2ME_sms_save_result(MSG_J2ME_SMS_CHECK_INCOMING_MSG_RSP, (int)p->result);
        }
            break;

        case MSG_ID_MMIAPI_SMS_GET_INCOMING_MSG_RSP:
        {
            mmiapi_sms_get_incoming_msg_rsp_struct *p =
                (mmiapi_sms_get_incoming_msg_rsp_struct*) ilm_ptr->local_para_ptr;

            J2ME_sms_save_result(MSG_J2ME_SMS_GET_INCOMING_MSG_RSP, (int)KAL_TRUE);

            j2me_sms_receive_len = p->message_len;
            J2ME_sms_free_data();
            j2me_sms_recceive_data_ptr = (void*)p->message;
        }
            break;

        default:
            ASSERT(0);
            break;

    }

    /* notify J2ME thread to process coming async event */
    kal_set_eg_events(J2ME_async_sms_eventgroup, 1, KAL_OR);

    return;
}


#ifdef __MMI_DUAL_SIM_MASTER__
/*****************************************************************************
 * FUNCTION
 *  J2ME_sms_register_sim_type
 * DESCRIPTION
 *  register sms port and type
 * PARAMETERS
 *  portNumber      [IN]        
 *  type            [IN]        
 * RETURNS
 *  0 if success, -1 else
 *****************************************************************************/
int J2ME_sms_register_sim_type(long portNumber, int type, kal_uint8 sim_type)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    mmiapi_blocking_data_struct *blocking;
    mmiapi_sms_register_port_req_struct *p;
    int ret;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_INFO, WMA_SMS_REGISTER, (int)portNumber, (int)type);

    /* Only when the port is not registered, it can apply registration to low-layer */
    p = NEW_LOCAL_PTR(mmiapi_sms_register_port_req_struct);

    blocking = mmiapi_get_blocking_data(MOD_JASYN);

    p->blocking_data = blocking;
    p->enable = KAL_TRUE;
    p->port_number = (int)portNumber;
    if (sim_type == JWA_SMS_SIM_TYPE_SIM2)
    {
        p->isSlave = KAL_TRUE;
    }
    else
    {
        p->isSlave = KAL_FALSE;
    }

    SEND_MESSAGE(MOD_JASYN, MOD_MMI, MMI_J2ME_SAP, MSG_ID_MMIAPI_SMS_REGISTER_PORT_REQ, p, NULL);

    kal_trace(TRACE_INFO, WMA_SMS_REGISTER1);
    mmiapi_lock(MOD_JASYN); /* waiting the register port number result */
    kal_trace(TRACE_INFO, WMA_SMS_REGISTER2, (int)(blocking->result));

    if ((type == WMA_REGISTRY) && blocking->result)
    {
        /* register success, and we should unregister port when VM shutdown */
        resouceRegistering(
            JAVA_WMA_SMS_DEVICE,
            (int)portNumber,
            NULL,
            NULL,
            J2ME_sms_unregister_by_resource_manager);
    }

    ret = blocking->result ? 0 : -1;

    return ret;
}


/*****************************************************************************
 * FUNCTION
 *  J2ME_sms_unregister
 * DESCRIPTION
 *  
 * PARAMETERS
 *  portNumber      [IN]        
 *  type            [IN]        
 * RETURNS
 *  
 *****************************************************************************/
int J2ME_sms_unregister_sim_type(long portNumber, int type, kal_uint8 sim_type)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    mmiapi_blocking_data_struct *blocking;
    mmiapi_sms_register_port_req_struct *p;
    int ret;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_INFO, WMA_SMS_UNREGISTER, portNumber);

    p = NEW_LOCAL_PTR(mmiapi_sms_register_port_req_struct);
    blocking = mmiapi_get_blocking_data(MOD_JASYN);

    p->blocking_data = blocking;
    p->enable = KAL_FALSE;
    p->port_number = (int)portNumber;
    p->remove_reminder_data = KAL_TRUE;
    if (sim_type == JWA_SMS_SIM_TYPE_SIM2)
    {
        p->isSlave = KAL_TRUE;
    }
    else
    {
        p->isSlave = KAL_FALSE;
    }

    SEND_MESSAGE(MOD_JASYN, MOD_MMI, MMI_J2ME_SAP, MSG_ID_MMIAPI_SMS_REGISTER_PORT_REQ, p, NULL);

    kal_trace(TRACE_INFO, WMA_SMS_UNREGISTER2);
    mmiapi_lock(MOD_JASYN); /* waiting the unregister port number result */
    kal_trace(TRACE_INFO, WMA_SMS_UNREGISTER3, blocking->result);

    ret = blocking->result ? 0 : -1;

    resouceDereg(JAVA_WMA_SMS_DEVICE, portNumber);

    return ret;
}
#endif /* __MMI_DUAL_SIM_MASTER__ */


/*****************************************************************************
 * FUNCTION
 *  J2ME_sms_register
 * DESCRIPTION
 *  register sms port and type
 * PARAMETERS
 *  portNumber      [IN]        
 *  type            [IN]        
 * RETURNS
 *  0 if success, -1 else
 *****************************************************************************/
int J2ME_sms_register(long portNumber, int type)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
#ifndef __MMI_DUAL_SIM_MASTER__
    mmiapi_blocking_data_struct *blocking;
    mmiapi_sms_register_port_req_struct *p;
#endif /* __MMI_DUAL_SIM_MASTER__ */
    int ret;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_INFO, WMA_SMS_REGISTER, (int)portNumber, (int)type);

    ret = j2me_check_push_register_port(portNumber, type);

    if (ret == NON_REGISTERED)
    {

#ifdef __MMI_DUAL_SIM_MASTER__
        ret = J2ME_sms_register_sim_type(portNumber, type, JWA_SMS_SIM_TYPE_SIM1);

        if (ret == 0)
        {
            ret = J2ME_sms_register_sim_type(portNumber, type, JWA_SMS_SIM_TYPE_SIM2);

            /* If SIM2 registration fails, rollback SIM1 registration */
            if (ret != 0)
            {
                J2ME_sms_unregister_sim_type(portNumber, type, JWA_SMS_SIM_TYPE_SIM1);
            }
        }

#else /* __MMI_DUAL_SIM_MASTER__ */

        /* Only when the port is not registered, it can apply registration to low-layer */
        p = NEW_LOCAL_PTR(mmiapi_sms_register_port_req_struct);

        blocking = mmiapi_get_blocking_data(MOD_JASYN);

        p->blocking_data = blocking;
        p->enable = KAL_TRUE;
        p->port_number = (int)portNumber;

        SEND_MESSAGE(MOD_JASYN, MOD_MMI, MMI_J2ME_SAP, MSG_ID_MMIAPI_SMS_REGISTER_PORT_REQ, p, NULL);

        kal_trace(TRACE_INFO, WMA_SMS_REGISTER1);
        mmiapi_lock(MOD_JASYN); /* waiting the register port number result */
        kal_trace(TRACE_INFO, WMA_SMS_REGISTER2, (int)(blocking->result));

        if ((type == WMA_REGISTRY) && blocking->result)
        {
            /* register success, and we should unregister port when VM shutdown */
            resouceRegistering(
                JAVA_WMA_SMS_DEVICE,
                (int)portNumber,
                NULL,
                NULL,
                J2ME_sms_unregister_by_resource_manager);
        }

        ret = blocking->result ? 0 : -1;
		
#endif /* __MMI_DUAL_SIM_MASTER__ */ 
    }

    return ret;
}


/*****************************************************************************
 * FUNCTION
 *  J2ME_sms_unregister
 * DESCRIPTION
 *  
 * PARAMETERS
 *  portNumber      [IN]        
 *  type            [IN]        
 * RETURNS
 *  
 *****************************************************************************/
int J2ME_sms_unregister(long portNumber, int type)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
#ifndef __MMI_DUAL_SIM_MASTER__
    mmiapi_blocking_data_struct *blocking;
    mmiapi_sms_register_port_req_struct *p;
#else /* __MMI_DUAL_SIM_MASTER__  */
    kal_int32 ret_sim1;
    kal_int32 ret_sim2;
#endif /* __MMI_DUAL_SIM_MASTER__  */
    int ret;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_INFO, WMA_SMS_UNREGISTER, portNumber);

    ret = j2me_check_push_register_port(portNumber, type);

    kal_trace(TRACE_INFO, WMA_SMS_UNREGISTER1, ret);

    if (((type == WMA_REGISTRY) && (ret != PUSH_REGISTERED) && (ret != PUSH_CONFLICT_REGISTERED)) || 
        ((type == PUSH_REGISTRY) && (ret == PUSH_REGISTERED)))
    {

#ifdef __MMI_DUAL_SIM_MASTER__

        ret_sim1 = J2ME_sms_unregister_sim_type(portNumber, type, JWA_SMS_SIM_TYPE_SIM1);
        ret_sim2 = J2ME_sms_unregister_sim_type(portNumber, type, JWA_SMS_SIM_TYPE_SIM2);

        if (ret_sim1 == 0 && ret_sim2 == 0)
        {
            ret = 0;
        }
        else
        {
            ret = -1;
        }
#else /* __MMI_DUAL_SIM_MASTER__ */