event_handler.c

MTK平台QQ移植

        mmi_frm_post_block_interrupt_event_handler,
        MMI_FRM_INT_EVENT_GENERAL);
}


/*****************************************************************************
 * FUNCTION
 *  mmi_frm_clear_interrupt_event_handler
 * DESCRIPTION
 *  This function could clear the designated interrupt event handler.
 * PARAMETERS
 *  interrupt_event       [IN]       framework interrupt event macro
 * RETURNS
 *  void
 *****************************************************************************/
void mmi_frm_clear_interrupt_event_handler(mmi_frm_int_event_type interrupt_event)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    U8 count;
    
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    MMI_TRACE(MMI_FW_TRC_G1_FRM, MMI_FRM_INFO_EVENT_CLRINTP_HDLR, interrupt_event);
    if ((interrupt_event & MMI_FRM_INT_NON_MMI_TASK_EVENTS) && mmi_frm_process_non_mmi_task)
    {
        mmi_frm_process_non_mmi_task_interrupt(interrupt_event, MMI_FALSE);
    }

    for (count = MMI_FRM_INT_EVENT_SPECIFIC; count < MMI_FRM_INT_EVENT_TYPE_NUM; count++)
    {
        if (interrupt_event & mmi_frm_int_mask_hdlr[count].event_mask)
        {
            mmi_frm_int_mask_hdlr[count].event_mask &= ~interrupt_event;
        }
    }
}


/*****************************************************************************
 * FUNCTION
 *  mmi_frm_clear_all_interrupt_event_handler
 * DESCRIPTION
 *  This function could clear all the interrupt event handler.
 * PARAMETERS
 *  interrupt_event       [IN]       framework interrupt event macro
 * RETURNS
 *  void
 *****************************************************************************/
void mmi_frm_clear_all_interrupt_event_handler(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    MMI_TRACE(MMI_FW_TRC_G1_FRM, MMI_FRM_INFO_EVENT_CLRALLINTP_HDLR);

    memset(mmi_frm_int_mask_hdlr, 0, sizeof(mmi_frm_int_mask_hdlr));
}

/*****************************************************************************
 * FUNCTION
 *  mmi_frm_reset_interrupt_event_context
 * DESCRIPTION
 *  This function could reset interrupt event context and clear all interrupt
 *  event handler.
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
void mmi_frm_reset_interrupt_event_context(void)
{
    /*----------------------------------------------------------------*/
    /* 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 (mmi_frm_process_non_mmi_task)
    {
        #ifdef __MMI_MMS__
        if (mmi_frm_query_interrupt_event_information(MMI_FRM_INT_WAP_MMS, NULL, NULL))
        {
            wap_suppress_popup(KAL_FALSE);
        }
        #endif /* __MMI_MMS__ */
        #if defined(__MMI_OPP_SUPPORT__) && defined(__MMI_BT_MTK_SUPPORT__)
        if (mmi_frm_query_interrupt_event_information(MMI_FRM_INT_BT_TASK, NULL, NULL))
        {
            mmi_bt_opp_suppress_popup(MMI_FALSE);
        }
        #endif /* defined(__MMI_OPP_SUPPORT__) && defined(__MMI_BT_MTK_SUPPORT__) */
        mmi_frm_process_non_mmi_task = MMI_FALSE;
    }

    mmi_frm_clear_all_interrupt_event_handler();
}


#ifdef MMI_FRM_BACKWARD_COMPATIBLE_EVENTS
/*****************************************************************************
 * FUNCTION
 *  mmi_frm_is_interrupt_group_table
 * DESCRIPTION
 *  search interrupt group event id is in interrupt
 *  group table and get the index
 * PARAMETERS
 *  eventID     [IN]     Unique Protocol/System EventID.   
 *  index       [OUT]    The index in the interrupt group table. If not find the
 *                       index is -1.
 * RETURNS
 *  MMI_BOOL
 *****************************************************************************/
static MMI_BOOL mmi_frm_is_interrupt_group_table(U16 event_id, int *index)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    int i;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    for (i = 0; i < sizeof(interruptGroupEventTable) / sizeof(InterruptGroupInfo); i++)
    {
        if (interruptGroupEventTable[i].groupID == event_id)
        {
            *index = i;
            return MMI_TRUE;
        }
    }

    *index = -1;
    return MMI_FALSE;
}


/*****************************************************************************
 * FUNCTION
 *  mmi_frm_query_interrupt_handler
 * DESCRIPTION
 *  query interrupt event handler
 * PARAMETERS
 *  eventID         [IN]   Unique Protocol/System EventID.      
 *  funcPtr         [OUT]  Function to be executed when receiving the interrupt event.     
 *  postfuncPtr     [OUT]  Function to be executed after receiving the interrupt event       
 * RETURNS
 *  MMI_BOOL
 *****************************************************************************/
static MMI_BOOL mmi_frm_query_interrupt_handler(U16 event_id, PsIntFuncPtr *func_ptr, PsIntFuncPtr *post_func_ptr)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    int i, j, index;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    for (i = 0; i < MAX_INTERRUPT_EVENT; i++)
    {
        if (!IS_INTERRUPT_EVENT_GROUP(interruptEventHandler[i].eventID))
        {
            /* General interrupt event */
            if (interruptEventHandler[i].eventID == event_id)
            {
                goto is_found;
            }
        }
        else
        {
            if (mmi_frm_is_interrupt_group_table(interruptEventHandler[i].eventID, &index))
            {
                /* Interrupt group event */
                j = 0;
                while (interruptGroupEventTable[index].eventID[j] != 0)
                {
                    if (interruptGroupEventTable[index].eventID[j] == event_id)
                    {
                        goto is_found;
                    }
                    j++;

                    MMI_ASSERT(j < INTERRUPT_EVENT_GREOUP_SIZE);
                }
            }
        }
    
}
    return MMI_FALSE;

  is_found:
    *func_ptr = (PsIntFuncPtr) interruptEventHandler[i].entryIntFuncPtr;
    *post_func_ptr = (PsIntFuncPtr) interruptEventHandler[i].postIntFuncPtr;
    return MMI_TRUE;
}


/*****************************************************************************
 * FUNCTION
 *  mmi_frm_set_interrupt_event_handler
 * DESCRIPTION
 *  This function is used for register the interrupt event handler. Whenever 
 *  an event is received from the protocol corresponding function is executed.
 *  If the interrupt event handlers are registered, MMI framework  executes 
 *  the functions as follow order: Inpterrupt Event Handler, Protocol Event 
 *  Handler, Post Interrupt Event Handler.
 * PARAMETERS
 *  funcPtr         [IN] Function to be executed when receiving the interrupt event.       
 *  postfuncPtr     [IN] Function to be executed after receiving the interrupt event.       
 *  eventID         [IN] Unique Protocol/System EventID.       
 * RETURNS
 *  void
 *****************************************************************************/
void mmi_frm_set_interrupt_event_handler(PsIntFuncPtr func_ptr, PsIntFuncPtr post_func_ptr, U16 event_id)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    S16 count = 0;
    pBOOL isNewEvent = TRUE;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    MMI_TRACE(MMI_FW_TRC_G1_FRM, MMI_FRM_INFO_EVENT_SETINTP_HDLR, event_id);

    if (!IS_INTERRUPT_EVENT_GROUP(event_id))
    {
        /* General interrupt event will allocate from the begin */
        for (count = 0; count < maxInterruptEvent; count++)
        {
            if (interruptEventHandler[count].eventID == event_id)
            {
                isNewEvent = FALSE;
                break;
            }
            if (interruptEventHandler[count].eventID == 0)
            {
                break;
            }
        }
    }
    else
    {
        /* Interrupt group event will allocate from the end */
        for (count = MAX_INTERRUPT_EVENT - 1; count >= 0; count--)
        {
            if (interruptEventHandler[count].eventID == event_id)
            {
                isNewEvent = FALSE;
                break;
            }
            if (interruptEventHandler[count].eventID == 0)
            {
                break;
            }
        }
    }

    if (isNewEvent)
    {
        maxInterruptEvent++;
        MMI_ASSERT(maxInterruptEvent < MAX_INTERRUPT_EVENT);
    }

    interruptEventHandler[count].eventID = event_id;
    interruptEventHandler[count].entryIntFuncPtr = func_ptr;
    interruptEventHandler[count].postIntFuncPtr = post_func_ptr;
}


/*****************************************************************************
 * FUNCTION
 *  mmi_frm_set_group_interrupt_event_handler
 * DESCRIPTION
 *  This function is used for register the group interrupt event handlers. 
 *  If the interrupt event handlers are registered, MMI framework  executes 
 *  the functions as follow order: InpterruptFuncPtr, ProtocolFuncPtr, 
 *  InterruptPostfuncPtr.
 * PARAMETERS
 *  funcPtr         [IN] Function to be executed when receiving the interrupt event.       
 *  postfuncPtr     [IN] Function to be executed after receiving the interrupt event.       
 *  eventsID        [IN] Unique Protocol/System EventID array.       
 *  len             [IN] The EventsID array size.       
 * RETURNS
 *  void
 *****************************************************************************/
void mmi_frm_set_group_interrupt_event_handler(PsIntFuncPtr func_ptr, PsIntFuncPtr post_func_ptr, PU16 events_id, U8 len)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    U8 count;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    for (count = 0; count < len; count++)
    {
        MMI_TRACE(MMI_FW_TRC_G1_FRM, MMI_FRM_INFO_EVENT_SETGRPINTP_HDLR, events_id[count]);
        mmi_frm_set_interrupt_event_handler(func_ptr, post_func_ptr, events_id[count]);
    }
}


/*****************************************************************************
 * FUNCTION
 *  mmi_frm_clear_interrupt_event_handler_old
 * DESCRIPTION
 *  This is used to clear interrupt event handler
 * PARAMETERS
 *  eventID     [IN] Clear the handler of event ID.       
 * RETURNS
 *  void
 *****************************************************************************/
void mmi_frm_clear_interrupt_event_handler_old(U16 event_id)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    MMI_TRACE(MMI_FW_TRC_G1_FRM, MMI_FRM_INFO_EVENT_CLRINTP_HDLR, event_id);
    mmi_frm_set_interrupt_event_handler(NULL, NULL, event_id);
}


/*****************************************************************************
 * FUNCTION
 *  mmi_frm_clear_all_interrupt_event_handler_old
 * DESCRIPTION
 *  This is used to clear all the interrupt event handlers
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
void mmi_frm_clear_all_interrupt_event_handler_old(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    MMI_TRACE(MMI_FW_TRC_G1_FRM, MMI_FRM_INFO_EVENT_CLRALLINTP_HDLR);

    memset(interruptEventHandler, 0, sizeof(PsInteventInfo)*maxInterruptEvent);

    maxInterruptEvent = 0;
}
#endif /*MMI_FRM_BACKWARD_COMPATIBLE_EVENTS*/