jvm_screen_switch.c

java 1.1 gemini 08_16

 *  jvm_resmgr_lcd_controller
 * DESCRIPTION
 *  manage LCD depending upon the source state and destination state of VM
 * PARAMETERS
 *  src     [IN]        
 *  dst     [IN]        
 * RETURNS
 *****************************************************************************/
kal_int32 jvm_resmgr_lcd_controller(jvm_state_enum src, jvm_state_enum dst)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_bool is_resume = src != JVM_TERMINATE_STATE ? KAL_TRUE : KAL_FALSE;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (dst == JVM_FG_RUNNING_STATE)
    {
        entry_full_screen();

        if (!is_resume)
        {
            jui_lcd_mutex_lock();
            jui_widget_set_screen_mode(JUI_SCREEN_MODE_NORMAL);
            jui_lcd_mutex_unlock();
        }

        if (is_resume)
        {
            jui_lcd_mutex_lock();
            jui_widget_register_lcd((BOOL) jvm_refresh_screen_after_resume);    /* LCD */
            jui_lcd_mutex_unlock();

            jui_widget_resume_screen();

            if (jui_widget_is_in_menu())
            {
                jui_lcd_mutex_lock();
                jui_widget_draw_menu();
                jui_lcd_mutex_unlock();
            }
        }

    #ifdef __MMI_SUBLCD__   /* SUBLCD */
        ForceSubLCDScreen(jvm_entry_sublcd_screen);
    #endif 

    }
    else if (src == JVM_FG_RUNNING_STATE)
    {
        jui_lcd_mutex_lock();
        jui_widget_unregister_lcd();    /* LCD */
        jui_lcd_mutex_unlock();

    #ifdef __MMI_SUBLCD__   /* SUBLCD, Should after release audio/vedio */
        GoBackSubLCDHistory();
    #endif 
    }

#ifdef J2ME_SUPPORT_BACKGROUND
    if (dst == JVM_BG_RUNNING_STATE)
    {
        if (jui_bg_vm_audio)
        {
            ShowStatusIcon(STATUS_ICON_JAVA_BG_VM_AUDIO);
        }
        else
        {
            ShowStatusIcon(STATUS_ICON_JAVA_BG_VM);
        }
        UpdateStatusIcons();
    }
    else if (src == JVM_BG_RUNNING_STATE)
    {
        HideStatusIcon(STATUS_ICON_JAVA_BG_VM);
        HideStatusIcon(STATUS_ICON_JAVA_BG_VM_AUDIO);
        UpdateStatusIcons();
    }
#endif /* J2ME_SUPPORT_BACKGROUND */ 

    return 0;
}


/*****************************************************************************
 * FUNCTION
 *  jvm_resmgr_device_controller
 * DESCRIPTION
 *  manage device depending upon the source state and destination state of VM
 * PARAMETERS
 *  src     [IN]        
 *  dst     [IN]        
 * RETURNS
 *****************************************************************************/
kal_int32 jvm_resmgr_device_controller(jvm_state_enum src, jvm_state_enum dst)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_bool is_resume = KAL_FALSE;
    kal_bool is_pause = KAL_FALSE;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (dst == JVM_FG_RUNNING_STATE)    /* resume and enter  5 */
    {
        if (src != JVM_TERMINATE_STATE)
        {
            is_resume = KAL_TRUE;
        }

        /*****************************************
         * VIBRATE and BACKLIGHT and AUDIO VIDEO *
         * Must Before Audio Switch              *
         *****************************************/
        jvm_GetDeviceControl(is_resume);
    }
    else if (src == JVM_FG_RUNNING_STATE)   /* event and terminate  3 */
    {
        /*****************************************
         * VIBRATE and BACKLIGHT and AUDIO VIDEO *
         * Must before unregister lcd            *
         *****************************************/

        if (dst != JVM_TERMINATE_STATE)
        {
            is_pause = KAL_TRUE;
        }
        jvm_ReleaseDeviceControl(is_pause);
    }

    /* do nothing */
    /*
     * else if( (src == JVM_SHORT_EVENT_STATE && dst == JVM_TERMINATE_STATE) ||
     * (src == JVM_LONG_EVENT_STATE && dst == JVM_TERMINATE_STATE) ||
     * (src == JVM_LONG_EVENT_STATE && dst == JVM_BG_RUNNING_STATE) ||
     * (src == JVM_LONG_EVENT_STATE && dst == JVM_PAUSED_STATE))
     * {
     * 
     * }
     * 
     * else
     * {
     * 
     * short event -> long event
     * pause -> terminate
     * background -> terminate
     * }
     */
    return 0;
}


/*****************************************************************************
 * FUNCTION
 *  jvm_resmgr_audio_controller
 * DESCRIPTION
 *  manage audio depending upon the source state and destination state of VM
 *  Active state of audio player:
 *  (1) JVM_FG_RUNNING_STATE
 *  (2) JVM_BG_RUNNING_STATE
 *  (3) JVM_SHORT_EVENT_STATE
 * PARAMETERS
 *  src     [IN]        
 *  dst     [IN]        
 * RETURNS
 *****************************************************************************/
kal_int32 jvm_resmgr_audio_controller(jvm_state_enum src, jvm_state_enum dst)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    /* Init parameter. The line should be put at the beginning of the function */
    if (src == JVM_TERMINATE_STATE && dst == JVM_FG_RUNNING_STATE)
    {
        jma_media_player_clear_parameter(KAL_TRUE);
    }

    /********************************************************************
     * Everytime when Java is FG running, Re-register background callback
     * as highest priority. Deregister background callback until java wants
     * to resume MMI background audio.
     ********************************************************************/
    if (dst == JVM_FG_RUNNING_STATE)
    {
        mdi_audio_set_headset_mode_output_path(MDI_DEVICE_SPEAKER2);
    #if defined(__MMI_BT_AUDIO_VIA_SCO__)
        /* The two funcion must be invoked in MMI's context */
        mmi_profiles_bt_connect_audio_via_sco();
        mmi_profiles_bt_disable_sco_timeout();
    #endif /* defined(__MMI_BT_AUDIO_VIA_SCO__) */ 

        /* Stop MMI audio if java does not play audio */
        if (!jma_audio_player_is_really_active())
        {
            mdi_audio_stop_all();
        }
        mdi_audio_set_background_handler(MDI_BACKGROUND_APP_JAVA, jma_audio_player_background_callback);
    }
    else if (src == JVM_FG_RUNNING_STATE && dst == JVM_BG_RUNNING_STATE ||
             src == JVM_LONG_EVENT_STATE && dst == JVM_BG_RUNNING_STATE)
    {
        if (jma_audio_player_is_active())
        {
            /* Java must be highest priority. */
            mdi_audio_clear_other_background_handler(MDI_BACKGROUND_APP_JAVA);
        }
        else
        {
            mdi_audio_clear_background_handler(MDI_BACKGROUND_APP_JAVA);
        }
    }
    else if (src == JVM_LONG_EVENT_STATE && dst == JVM_PAUSED_STATE)
    {
        mdi_audio_clear_background_handler(MDI_BACKGROUND_APP_JAVA);
    }
    else if (src == JVM_LONG_EVENT_STATE && dst == JVM_TERMINATE_STATE)
    {
        /* The line is put at the following */
        /* mdi_audio_clear_background_handler(MDI_BACKGROUND_APP_JAVA); */
    }

    /********************************************************************
     * When VM state changes, MMAPI should call corresponding handler.  *
     ********************************************************************/
    if (src == JVM_FG_RUNNING_STATE && dst == JVM_LONG_EVENT_STATE ||
        src == JVM_SHORT_EVENT_STATE && dst == JVM_LONG_EVENT_STATE)
    {
        jma_audio_player_vm_notify_suspend();
    }
    else if (src == JVM_LONG_EVENT_STATE && dst == JVM_FG_RUNNING_STATE ||
             src == JVM_LONG_EVENT_STATE && dst == JVM_BG_RUNNING_STATE ||
             src == JVM_PAUSED_STATE && dst == JVM_FG_RUNNING_STATE)
    {
        jma_audio_player_vm_notify_resume();
    }
    else if (src == JVM_BG_RUNNING_STATE && dst == JVM_FG_RUNNING_STATE)
    {
        /* If Java audio is interrupted by MMI,
           resume JAVA audio before Java is foreground running */
        if (is_med_suspend_audio)
        {
            jma_audio_player_background_callback(MDI_AUDIO_RESUME);
        }
    }
    else if (dst == JVM_TERMINATE_STATE)
    {
        jma_audio_player_do_terminate_job(src);

        mdi_audio_clear_background_handler(MDI_BACKGROUND_APP_JAVA);
    #if defined(__MMI_BT_AUDIO_VIA_SCO__)
        mmi_profiles_bt_enable_sco_timeout();
    #endif 
    }

    /* Reset parameter. The line should be put at the end of the function */
    if (dst == JVM_TERMINATE_STATE)
    {
        jma_media_player_clear_parameter(KAL_FALSE);
    }
    return 0;
}


/*****************************************************************************
 * FUNCTION
 *  jvm_resmgr_video_controller
 * DESCRIPTION
 *  manage video depending upon the source state and destination state of VM
 * PARAMETERS
 *  src     [IN]        
 *  dst     [IN]        
 * RETURNS
 *****************************************************************************/
kal_int32 jvm_resmgr_video_controller(jvm_state_enum src, jvm_state_enum dst)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (src == JVM_FG_RUNNING_STATE && dst == JVM_SHORT_EVENT_STATE ||
        src == JVM_FG_RUNNING_STATE && dst == JVM_LONG_EVENT_STATE ||
        src == JVM_FG_RUNNING_STATE && dst == JVM_BG_RUNNING_STATE)
    {
        jma_media_player_vm_notfy_suspend();
    }
    else if (src == JVM_SHORT_EVENT_STATE && dst == JVM_FG_RUNNING_STATE ||
             src == JVM_LONG_EVENT_STATE && dst == JVM_FG_RUNNING_STATE ||
             src == JVM_PAUSED_STATE && dst == JVM_FG_RUNNING_STATE ||
             src == JVM_BG_RUNNING_STATE && dst == JVM_FG_RUNNING_STATE)
    {
        jma_media_player_vm_notfy_resume();
    }
    else if (dst == JVM_TERMINATE_STATE)
    {
        jma_media_player_vm_notfy_terminate();
    }
    return 0;
}


/*****************************************************************************
 * FUNCTION
 *  jvm_resmgr_graphics3d_controller
 * DESCRIPTION
 *  manage M3G depending upon the source state and destination state of VM
 * PARAMETERS
 *  src     [IN]        
 *  dst     [IN]        
 * RETURNS
 *****************************************************************************/
kal_int32 jvm_resmgr_graphics3d_controller(jvm_state_enum src, jvm_state_enum dst)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
#ifdef SUPPORT_JSR_184
    if (src == JVM_TERMINATE_STATE && dst == JVM_FG_RUNNING_STATE)
    {
        jm3g_register_graphics3d();
    }
    else if (src == JVM_FG_RUNNING_STATE && dst == JVM_TERMINATE_STATE)
    {
        jm3g_unregister_graphics3d();
    }
#endif /* SUPPORT_JSR_184 */ 
    return 0;
}


/*****************************************************************************
 * FUNCTION
 *  jvm_resmgr_event_controller
 * DESCRIPTION
 *  manage enent handling depending upon the source state and destination state of VM
 * PARAMETERS
 *  src     [IN]        
 *  dst     [IN]        
 * RETURNS
 *****************************************************************************/
kal_int32 jvm_resmgr_event_controller(jvm_state_enum src, jvm_state_enum dst)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_bool is_resume = KAL_FALSE;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (dst == JVM_FG_RUNNING_STATE)
    {
        if (src != JVM_TERMINATE_STATE)
        {
            is_resume = KAL_TRUE;
        }
        jvm_register_keypad(is_resume); /* KEYPAD */
        jvm_register_pen_events();      /* PEN EVENT */
    }
    else if (src == JVM_FG_RUNNING_STATE)
    {
        jvm_unregister_keypad();        /* KEYPAD */
        jvm_unregister_pen_events();    /* PEN EVENT */
    }
    return 0;
}