event_handler.c

MTK平台QQ移植

 *  This function could query interrupt event information.
 * PARAMETERS
 *  eventID      [IN]        interrupt event id
 *  int_func     [OUT]       interrupt event pre handler
 *  post_int_func[OUT]       interrupt event post handler   
 * RETURNS
 *  Return MMI_TURE if find the information slot, otherwise, return MMI_FLASE
 *****************************************************************************/
static MMI_BOOL mmi_frm_query_interrupt_event_information(mmi_frm_int_event_type frm_int_event, interrupt_event_hdlr *int_func, interrupt_event_hdlr *post_int_func)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    int count;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    /* We set specific interrupt event as higher priority than general ones */
    for (count = MMI_FRM_INT_EVENT_SPECIFIC; count < MMI_FRM_INT_EVENT_TYPE_NUM; count++)
    {
        if (frm_int_event & mmi_frm_int_mask_hdlr[count].event_mask)
        {
            if (int_func)
            {
                *int_func = mmi_frm_int_mask_hdlr[count].int_func_ptr;
            }
            if (post_int_func)
            {
                *post_int_func = mmi_frm_int_mask_hdlr[count].post_int_func_ptr;
            }
            return MMI_TRUE;
        }
    }
    
    return MMI_FALSE;
}


/*****************************************************************************
 * FUNCTION
 *  mmi_frm_get_frm_int_event_macro
 * DESCRIPTION
 *  This function will get framework interrupt event macro from convert table
 * PARAMETERS
 *  event_id       [IN]       interrupt event id
 *  msg            [IN]       primitive's local parameter
 * RETURNS
 *  Reture framework interrupt event macro
 *****************************************************************************/
static mmi_frm_int_event_type mmi_frm_get_frm_int_event_macro(U16 int_event, const mmi_frm_int_event_convert_struct *int_event_convert_table, U8 table_size)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    U8  count;
    mmi_frm_int_event_type frm_int_event_macro = 0;
    
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    for (count = 0; count < table_size; count++)
    {
        if (int_event_convert_table[count].event_id == int_event)
        {
            frm_int_event_macro = int_event_convert_table[count].int_event_macro;
            break;
        }
    }
    return frm_int_event_macro;    
}


/*****************************************************************************
 * FUNCTION
 *  mmi_frm_interrupt_event_converter
 * DESCRIPTION
 *  This function will convert protocol interrupt event to framework interrupt
 *  event macro.
 * PARAMETERS
 *  event_id       [IN]       interrupt event id
 *  msg            [IN]       primitive's local parameter
 * RETURNS
 *  Reture framework interrupt event macro
 *****************************************************************************/
static mmi_frm_int_event_type mmi_frm_interrupt_event_converter(U16 event_id, void *msg)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    mmi_frm_int_event_type frm_interrupt_event = 0;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    switch (event_id)
    {
        case PRT_EQ_GPIO_DETECT_IND:
        {
            mmi_eq_gpio_detect_ind_struct *gpio_detect_ind = (mmi_eq_gpio_detect_ind_struct *)msg;
            switch (gpio_detect_ind->gpio_device)
            {
                case EXT_DEV_CLAM_CLOSE:
                {
                    frm_interrupt_event = MMI_FRM_INT_CLAM_CLOSE;
                    break;
                }
                case EXT_DEV_CLAM_OPEN:
                {
                    frm_interrupt_event = MMI_FRM_INT_CLAM_OPEN;
                    break;
                }
                case EXT_DEV_EARPHONE:
                {
                    if (gpio_detect_ind->on_off == 1)
                    {
                        frm_interrupt_event = MMI_FRM_INT_EARPHONE_PLUG_IN;
                    }
                    else
                    {
                        frm_interrupt_event = MMI_FRM_INT_EARPHONE_PLUG_OUT;
                    }
                    break;
                }
            }
            break;
        }
        case PRT_BATTERY_STATUS_IND:
        {
            mmi_eq_battery_status_ind_struct *battery_status_ind = (mmi_eq_battery_status_ind_struct*)msg;

            frm_interrupt_event = mmi_frm_get_frm_int_event_macro(
                                      battery_status_ind->battery_status,
                                      mmi_frm_int_event_battery_table,
                                      sizeof(mmi_frm_int_event_battery_table) / sizeof(mmi_frm_int_event_battery_table[0]));
            break;
        }
        case MSG_ID_TIMER_EXPIRY:
        case MSG_ID_MMI_EQ_POWER_ON_IND:
        case MSG_ID_MMI_EQ_KEYPAD_DETECT_IND:
        {
            break;
        }
        default:
        {
            frm_interrupt_event = mmi_frm_get_frm_int_event_macro(
                                      event_id, 
                                      mmi_frm_int_event_convert_table,
                                      sizeof(mmi_frm_int_event_convert_table) / sizeof(mmi_frm_int_event_convert_table[0]));
            break;
        }
    }
    return frm_interrupt_event;
}


/*****************************************************************************
 * FUNCTION
 *  mmi_frm_process_non_mmi_task_interrupt
 * DESCRIPTION
 *  This function is an internal one which will set interrupt event handler
 *  into interrupt information table.
 * PARAMETERS
 *  mmi_frm_int_event_type       [IN]       interrupt event
 *  is_set                       [IN]       set non-mmi task popup screen 
 * RETURNS
 *  void
 *****************************************************************************/
static void mmi_frm_process_non_mmi_task_interrupt(mmi_frm_int_event_type interrupt_event, MMI_BOOL is_set)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    MMI_BOOL mmi_arg = MMI_FALSE;
    kal_bool kal_arg = KAL_FALSE;
    
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (is_set)
    {
        mmi_arg = MMI_TRUE;
        kal_arg = KAL_TRUE;
    }

    #ifdef __MMI_MMS__
        if (interrupt_event & MMI_FRM_INT_WAP_MMS)
        {
            wap_suppress_popup(kal_arg);
        }        
    #endif /* __MMI_MMS__ */
    #if defined(__MMI_OPP_SUPPORT__) && defined(__MMI_BT_MTK_SUPPORT__)
        if (interrupt_event & MMI_FRM_INT_BT_TASK)
        {
            mmi_bt_opp_suppress_popup(mmi_arg);
        }        
    #endif /* defined(__MMI_OPP_SUPPORT__) && defined(__MMI_BT_MTK_SUPPORT__) */
    mmi_frm_process_non_mmi_task = is_set;
}


/*****************************************************************************
 * FUNCTION
 *  mmi_frm_block_interrupt_event_int
 * DESCRIPTION
 *  This function is an internal one which will set interrupt event handler
 *  into interrupt information table.
 * PARAMETERS
 *  int_event_p           [IN]       pre interrupt event handler
 *  post_int_event_p      [IN]       post interrupt event handler
 *  interrupt_event       [IN]       framework interrupt event macro
 *  event_type            [IN]       to decide general or specific event  
 * RETURNS
 *  void
 *****************************************************************************/
static void mmi_frm_block_interrupt_event_int(mmi_frm_int_event_type interrupt_event, interrupt_event_hdlr int_event_p, interrupt_event_hdlr post_int_event_p, U8 event_type)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    /* 
     * Non-MMI task interruption is not through the protocol event process, so it needs to set flag to 
     * stop popup screen after EntryNewScreen and reset it when exit the screen
     */
    if (interrupt_event & MMI_FRM_INT_NON_MMI_TASK_EVENTS)
    {
        if (int_event_p)
        {
            mmi_frm_process_non_mmi_task_interrupt(interrupt_event, MMI_TRUE);
        }
        else if (!int_event_p && mmi_frm_process_non_mmi_task)  /* if int_event_p is NULL which means user want to clear this handler */
        {
            mmi_frm_process_non_mmi_task_interrupt(interrupt_event, MMI_FALSE);
        }
    }

    /* This action will only register the events and handlers in the last time calling this interface */
    mmi_frm_int_mask_hdlr[event_type].event_mask = interrupt_event;
    mmi_frm_int_mask_hdlr[event_type].int_func_ptr = int_event_p;
    mmi_frm_int_mask_hdlr[event_type].post_int_func_ptr = post_int_event_p;
}


/*****************************************************************************
 * FUNCTION
 *  mmi_frm_pre_block_interrupt_event_handler
 * DESCRIPTION
 *  This function is an internal one which will block popup screen caused by
 *  interrupt event handler.
 * PARAMETERS
 *  interrupt_event       [IN]       framework interrupt event macro  
 * RETURNS
 *  Return MMI_FALSE to let protocol handler be executed, otherwise, 
 *  return MMI_TRUE.
 *****************************************************************************/
static U8 mmi_frm_pre_block_interrupt_event_handler(mmi_frm_int_event_type interrupt_event)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
	
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    switch (interrupt_event)
    {
        /* Now the default action is just to stop popup screen for general interrupt event */
        default:
        {
            SetInterruptPopupDisplay(POPUP_ALL_OFF);
            break;
        }
    }

    return MMI_FALSE;
}


/*****************************************************************************
 * FUNCTION
 *  mmi_frm_post_block_interrupt_event_handler
 * DESCRIPTION
 *  This function is an internal one which will reset the flag of popup screen.
 * PARAMETERS
 *  interrupt_event       [IN]       framework interrupt event macro  
 * RETURNS
 *  Return MMI_FALSE always (remain for expansion).
 *****************************************************************************/
static U8 mmi_frm_post_block_interrupt_event_handler(mmi_frm_int_event_type interrupt_event)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
	
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/    
    switch (interrupt_event)
    {
        /* Now the default action is just to stop popup screen for general interrupt event */
        default:
        {
            SetInterruptPopupDisplay(POPUP_ALL_ON);
            break;
        }
    }

    return MMI_FALSE;
}


/*****************************************************************************
 * FUNCTION
 *  mmi_frm_block_interrupt_event_handler
 * DESCRIPTION
 *  This function will set event handler which could process what application want 
 *  when the interrupt event is blocked by mmi task.
 * PARAMETERS
 *  interrupt_event       [IN]       framework interrupt event macro
 *  int_event_p           [IN]       pre interrupt event handler
 *  post_int_event_p      [IN]       post interrupt event handler
 * RETURNS
 *  void
 *****************************************************************************/
void mmi_frm_block_interrupt_event_handler(mmi_frm_int_event_type interrupt_event, interrupt_event_hdlr int_event_p, interrupt_event_hdlr post_int_event_p)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    MMI_TRACE(MMI_FW_TRC_G1_FRM, MMI_FRM_INFO_EVENT_BLOCK_INT_HDLR, interrupt_event);
    mmi_frm_block_interrupt_event_int(
        interrupt_event, 
        int_event_p,
        post_int_event_p,
        MMI_FRM_INT_EVENT_SPECIFIC);
}


/*****************************************************************************
 * FUNCTION
 *  mmi_frm_block_general_interrupt_event
 * DESCRIPTION
 *  This function could block all the interruptive popup screen when the general
 *  interrupt event is blocked by mmi task.
 * PARAMETERS
 *  interrupt_event       [IN]       framework interrupt event macro
 * RETURNS
 *  void
 *****************************************************************************/
void mmi_frm_block_general_interrupt_event(mmi_frm_int_event_type interrupt_event)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    MMI_TRACE(MMI_FW_TRC_G1_FRM, MMI_FRM_INFO_EVENT_BLOCK_GEN_INT_HDLR, interrupt_event);
    mmi_frm_block_interrupt_event_int(
        interrupt_event,    
        mmi_frm_pre_block_interrupt_event_handler,