jma_media_resource.c

java 1.1 gemini 08_16

 *  void
 *****************************************************************************/
void jma_media_player_dependency_mutex_lock(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/

    /************************************************************
     * MMI should lock dependency lock to sync the order with Java  
     ************************************************************/
    jui_lcd_mutex_lock();
    GDI_LOCK;
    MDI_AUDIO_LOCK;

}


/*****************************************************************************
 * FUNCTION
 *  jma_media_player_dependency_mutex_lock_no_wait
 * DESCRIPTION
 *  This function locks media dependency mutex(es) (no wait)
 * PARAMETERS
 *  none
 * RETURNS
 *  kal_bool
 *****************************************************************************/
kal_bool jma_media_player_dependency_mutex_lock_no_wait(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/

    /************************************************************
     * (1) For audio, Java should get MDI_LOCK only, but in order to avoid
     *     deadlock, Java MUST also get JUI_LCD and GDI_LOCK first.
     * (2) Video should also lock dependency lock to sync order with audio to avoid deadlock
     * (3) The three locks are unlocked in media_player_mutex_unlock() 
     ************************************************************/

    jui_lcd_mutex_lock();
    /* Get the 2nd lock */
    if (gdi_fast_mutex_lock_no_wait() == GDI_FAILED)
    {
        j2me_lcd_mutex_unlock();
        return KAL_FALSE;                
    }
    
    /* Get the 3rd lock */
    if (MDI_AUDIO_LOCK_NO_WAIT == MMI_FALSE)
    {
        GDI_UNLOCK;
        j2me_lcd_mutex_unlock();                
        return KAL_FALSE;  
    } 
    return KAL_TRUE;
}


/*****************************************************************************
 * FUNCTION
 *  jma_media_player_dependency_mutex_unlock
 * DESCRIPTION
 *  This function unlocks dependency mutex
 * PARAMETERS
 *  none
 * RETURNS
 *  void
 *****************************************************************************/
void jma_media_player_dependency_mutex_unlock(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    /* Unlock mutex locked at mutex_lock() */
    MDI_AUDIO_UNLOCK;
    GDI_UNLOCK;
    j2me_lcd_mutex_unlock();
}


/*****************************************************************************
 * FUNCTION
 *  jma_media_player_cs_check_and_enter
 * DESCRIPTION
 *  This function checks and enters audio critical section 
 * PARAMETERS
 *  is_audio_player (may rename as bg_running)
 * RETURNS
 *  kal_bool
 *****************************************************************************/
kal_bool _jma_media_player_cs_check_and_enter(kal_bool is_audio_player, kal_char *file, kal_uint32 line)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    module_type active_module_id = stack_int_get_active_module_id();
    kal_bool mmi_in_use = KAL_FALSE, bg_suspended = KAL_FALSE;
    kal_int32 order = -1, num = 0;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    MMI_PRINT(MOD_J2ME, TRACE_GROUP_8,"MMAPI: CS_ENTER: m=%d a=%d cnt=%d [%s, %d]", active_module_id, is_audio_player, j2me_media_mutex_cnt, basename(file), line);

    if (active_module_id != j2me_media_mutex_tid)
    {
        if (active_module_id == MOD_MMI) /* always wait */
        {
            jma_media_player_dependency_mutex_lock();
            kal_take_mutex(J2ME_media_mutex);
            j2me_media_mutex_tid = active_module_id;
        }
        else /* J2ME or Jblendia always does not wait */
        {
            if (jma_media_player_dependency_mutex_lock_no_wait() == KAL_FALSE)
            {
                return KAL_FALSE;
            }                           

            /* Protect the parameter */
            PARAM_CS_ENTER();

            kal_trace(TRACE_GROUP_8, INFO_J2ME_MMA_DD, jma_audio_enable, jma_media_enable);
            if(( is_audio_player && !jma_audio_enable) ||
               (!is_audio_player && !jma_media_enable))
            {
                PARAM_CS_LEAVE();
                jma_media_player_dependency_mutex_unlock();
                return KAL_FALSE;
            }   

            /* The 3rd condition: res_audio_controller has been invoked, for close_handler use */
            if (is_audio_player && jvm_get_state() != JVM_FG_RUNNING_STATE &&
                jvm_get_state() != JVM_TERMINATE_STATE) 
            {
                /* Check if MMI resource is in use now */
                mmi_in_use = !mdi_audio_is_able_to_use_by_other_task();
                /* Check if someone calls suspend background play */
                bg_suspended = mdi_audio_is_background_play_suspended();
                /* Check if Java is at first priority  */
                order = mdi_audio_get_background_callback_order(MDI_BACKGROUND_APP_JAVA);
                /* Check if bg play list is empty */
                num = mdi_audio_get_background_callback_register_app_num();
                kal_trace(TRACE_GROUP_8, INFO_J2ME_MMA_DDDD, mmi_in_use, bg_suspended, order, num);

                if (mmi_in_use || bg_suspended || (num != 0 && order != 0))
                {
                    PARAM_CS_LEAVE();
                    jma_media_player_dependency_mutex_unlock();
                    return KAL_FALSE;
                }
            }
            
            /* Remember java can not wait in C level */
            /* In theory, the above check should return directly if java needs to wait */
            kal_take_mutex(J2ME_media_mutex);
            
            PARAM_CS_LEAVE();
            
            j2me_media_mutex_tid = active_module_id;
        }      
    }
    j2me_media_mutex_cnt++;
    return KAL_TRUE;
}


/*****************************************************************************
 * FUNCTION
 *  jma_audio_player_cs_leave
 * DESCRIPTION
 *  This function leaves audio critical section 
 * PARAMETERS
 *  
 * RETURNS
 *  kal_bool
 *****************************************************************************/
void _jma_media_player_cs_leave(kal_char *file, kal_uint32 line)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    module_type active_module_id = stack_int_get_active_module_id();

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    MMI_PRINT(MOD_J2ME, TRACE_GROUP_8,"MMAPI: CS_LEAVE: m=%d cnt=%d [%s, %d]", active_module_id, j2me_media_mutex_cnt, basename(file), line);

    ASSERT(j2me_media_mutex_tid == active_module_id);

    j2me_media_mutex_cnt--;

    if (j2me_media_mutex_cnt == 0)
    {
        j2me_media_mutex_tid = MOD_NIL;
        kal_give_mutex(J2ME_media_mutex);
        jma_media_player_dependency_mutex_unlock();
    }    
}


/*****************************************************************************
 * FUNCTION
 *  jma_media_player_check_critical_section
 * DESCRIPTION
 *  This function checks criticla section
 * PARAMETERS
 *       
 * RETURNS
 *  kal_bool
 *****************************************************************************/
void jma_media_player_check_critical_section(void)
{
    /* Audio Playback */
    JMA_AUDIO_CS_ENTER(JMA_VOID);
    JMA_CS_LEAVE(JMA_VOID);

    /* Other */
    JMA_CS_ENTER(JMA_VOID);
    JMA_CS_LEAVE(JMA_VOID);
}


/*****************************************************************************
 * FUNCTION
 *  jma_reset_all_device
 * DESCRIPTION
 *  
 * PARAMETERS
 *  device_type     [IN]        
 *  handle          [IN]        
 * RETURNS
 *  
 *****************************************************************************/
void jma_reset_all_device(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_int32 i;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_GROUP_4, FUNC_J2ME_JMA_RESET_ALL_DEVICE);

    for (i = 0; i < JMA_MEDIA_DEVICE_NUM; i++)
    {
        jma_device[i].device_type = JAVA_MEDIA_INVALID_DEVICE;
        jma_device[i].handle = 0;
        jma_device[i].close = NULL;
        jma_device[i].resume = NULL;
        jma_device[i].suspend = NULL;
    }
}


/*****************************************************************************
 * FUNCTION
 *  jma_deregister_device
 * DESCRIPTION
 *  
 * PARAMETERS
 *  device_type     [IN]        
 *  handle          [IN]        
 * RETURNS
 *  
 *****************************************************************************/
void jma_deregister_device(int device_type, int handle)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_int32 i;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_GROUP_4, FUNC_J2ME_JMA_DEREGISTER_DEVICE, device_type, handle);

    for (i = 0; i < JMA_MEDIA_DEVICE_NUM; i++)
    {
        if ((jma_device[i].device_type == device_type) && (jma_device[i].handle == handle))
        {
            jma_device[i].device_type = JAVA_MEDIA_INVALID_DEVICE;
            jma_device[i].handle = 0;
            jma_device[i].close = NULL;
            jma_device[i].resume = NULL;
            jma_device[i].suspend = NULL;
            break;
        }
    }
}


/*****************************************************************************
 * FUNCTION
 *  jma_register_device
 * DESCRIPTION
 *  
 * PARAMETERS
 *  device_type     [IN]        
 *  handle          [IN]        
 *  suspend         [IN]        
 *  resume          [IN]        
 *  close           [IN]        
 * RETURNS
 *  
 *****************************************************************************/
void jma_register_device(
        kal_int32 device_type,
        kal_int32 handle,
        kal_int32 (*suspend) (kal_int32 handle),
        kal_int32 (*resume) (kal_int32 handle),
        kal_int32 (*close) (kal_int32 handle))
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_int32 i, empty_entry = -1;
    
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/       
    kal_trace(TRACE_GROUP_4, FUNC_J2ME_JMA_REGISTER_DEVICE, device_type, handle);

    /* Aleady register */
    for (i = 0; i < JMA_MEDIA_DEVICE_NUM; i++)
    {
        if ((jma_device[i].device_type == device_type) && (jma_device[i].handle == handle))
        {
            ASSERT(0);
        }
    }    

    /* Find out empty entry */
    for (i = 0; i < JMA_MEDIA_DEVICE_NUM; i++)
    {
        if (jma_device[i].device_type == JAVA_MEDIA_INVALID_DEVICE)
        {
            empty_entry = i;
            break;
        }
    }

    ASSERT(empty_entry != -1);
    
    jma_device[i].device_type = device_type;
    jma_device[i].handle = handle;
    jma_device[i].suspend = suspend;
    jma_device[i].resume = resume;
    jma_device[i].close = close;
}