开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > MTK > 查看源码
AppMemMgr.c
资源名称：mmi.rar　[点击查看]
上传用户：lqx1163
上传日期：2014-08-13
资源大小：9183k
文件大小：62k
源码类别：

MTK

开发平台：

C/C++

AppMemMgr.c：源码内容
  1. /*****************************************************************************
  2. *  Copyright Statement:
  3. *  --------------------
  4. *  This software is protected by Copyright and the information contained
  5. *  herein is confidential. The software may not be copied and the information
  6. *  contained herein may not be used or disclosed except with the written
  7. *  permission of MediaTek Inc. (C) 2005
  8. *
  9. *  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  10. *  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  11. *  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
  12. *  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
  13. *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
  14. *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
  15. *  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
  16. *  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
  17. *  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
  18. *  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
  19. *  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
  20. *  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
  21. *
  22. *  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
  23. *  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
  24. *  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
  25. *  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
  26. *  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. 
  27. *
  28. *  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
  29. *  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
  30. *  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
  31. *  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
  32. *  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
  33. *
  34. *****************************************************************************/
  35. /*****************************************************************************
  36.  *
  37.  * Filename:
  38.  * ---------
  39.  *  AppMemMgr.c
  40.  *
  41.  * Project:
  42.  * --------
  43.  *  MAUI
  44.  *
  45.  * Description:
  46.  * ------------
  47.  *  App-Based Shared Memory Manager
  48.  *
  49.  *  App-based shared memory is allocated before entering an application, and 
  50.  *  released when exiting an application. 
  51.  *
  52.  * Author:
  53.  * -------
  54.  * -------
  55.  *                      
  56.  *============================================================================
  57.  *             HISTORY
  58.  * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  59.  *------------------------------------------------------------------------------
  60.  * removed!
  61.  *
  62.  * removed!
  63.  * removed!
  64.  * removed!
  65.  *
  66.  * removed!
  67.  * removed!
  68.  * removed!
  69.  *
  70.  * removed!
  71.  * removed!
  72.  * removed!
  73.  *
  74.  * removed!
  75.  * removed!
  76.  * removed!
  77.  *
  78.  *------------------------------------------------------------------------------
  79.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  80.  *============================================================================
  81.  ****************************************************************************/
  83. /***************************************************************************** 
  84.  * Include
  85.  *****************************************************************************/
  86. #include "MMI_features.h"
  89. #include "stdC.h"
  90. #include "L4Dr1.h"
  91. #include "GlobalDefs.h"
  92. #include "DebugInitDef.h"
  93. #include "AppMemMgrGprot.h"
  94. #include "CommonScreensEnum.h"
  95. #include "CommonScreens.h"
  96. #include "SettingProfile.h"         /* for tone ID */
  97. #include "wgui_categories_fmgr.h"   /* Category 212 */
  98. #ifndef MMI_ON_WIN32
  99. #include "mmiapi_func.h"
  100. #endif
  103. #include "kal_non_specific_general_types.h"
  104. #include "app_mem.h"
  106. /***************************************************************************** 
  107.  * Define
  108.  *****************************************************************************/
  110. /***************************************************************************** 
  111.  * Typedef 
  112.  *****************************************************************************/
  114. /* States of mmi_frm_appmem_stop_confirm_screen_yes() */
  115. typedef enum
  116. {
  117.     /* Normal case */
  118.     MMI_FRM_APPMEM_STOP_STATE_IGNORE,
  119.     /* Inside mmi_frm_appmem_stop_confirm_screen_yes() */
  120.     MMI_FRM_APPMEM_STOP_STATE_WAITING,
  121.     /* Stop operation finished inside mmi_frm_appmem_stop_confirm_screen_yes() */
  122.     MMI_FRM_APPMEM_STOP_STATE_FINISHED
  123. } mmi_frm_appmem_stop_state_enum;
  125. /* Context of the prompt screen */
  126. typedef struct 
  127. {
  128.     /* Properties of the application requesting to free up more memory */
  129.     MMI_ID_TYPE app_name;
  130.     MMI_ID_TYPE app_icon;
  131.     /* Requested memory size */
  132.     U32 required_size;
  133.     MMI_BOOL require_full_pool;
  134.     /* Used inside mmi_frm_appmem_stop_confirm_screen_yes() */
  135.     mmi_frm_appmem_stop_state_enum stop_state;
  136.     kal_uint32 app_id_confirm_to_stop;
  137.     /* Keep SCR_APPMEM_STOP_PROMPT & SCR_APPMEM_STOP_PROGRESSING in history 
  138.        at its exit function. */
  139.     MMI_BOOL keep_prompt_screen_in_history;
  140.     void (*success_callback)(void);
  141. } mmi_frm_appmem_prompt_struct;
  143. typedef struct 
  144. {
  145.     /* Number of applications using App-based ASM */
  146.     S32 num_app;
  147.     /* Detailed information */
  148.     applib_mem_ap_usage_struct applist[MMI_FRM_APPMEM_MAX_APP_PROMPTED];
  149. } mmi_frm_appmem_prompt_screen_struct;
  151. /*****************************************************************************              
  152.  * Local Variable                                                                    
  153.  *****************************************************************************/
  155. /* Life cycle: prompt user to stop applications -> successfully get the memory or cancelled */
  156. static mmi_frm_appmem_prompt_struct g_mmi_frm_appmem_prompt;
  158. /* Life cycle: inside the prompt screen only (SCR_APPMEM_STOP_PROMPT) */
  159. static mmi_frm_appmem_prompt_screen_struct *g_mmi_frm_appmem_prompt_screen = NULL;
  161. /*****************************************************************************              
  162.  * Local Function                                                                    
  163.  *****************************************************************************/
  165. /* Prototype declarations: */
  166. static void mmi_frm_appmem_entry_prompt_screen(void);
  167. static void mmi_frm_appmem_entry_progressing_screen(void);
  168. static void mmi_frm_appmem_invoke_release_mem_success_callback(void);
  169. static void mmi_frm_appmem_stop_finished_handler(kal_uint32 app_id, kal_uint32 string_id, kal_bool result);
  171. /*****************************************************************************
  172.  * FUNCTION
  173.  *  mmi_frm_appmem_is_in_prompt_screens
  174.  * DESCRIPTION
  175.  *  Whether MMI is inside prompt screens (SCR_APPMEM_STOP_PROMPT and SCR_APPMEM_STOP_PROGRESSING)
  176.  * PARAMETERS
  177.  *  void
  178.  * RETURNS
  179.  *  MMI_BOOL
  180.  *****************************************************************************/
  181. static MMI_BOOL mmi_frm_appmem_is_in_prompt_screens(void)
  182. {
  183.     /*----------------------------------------------------------------*/
  184.     /* Local Variables                                                */
  185.     /*----------------------------------------------------------------*/
  186.     U16 curr_scr_id;
  188.     /*----------------------------------------------------------------*/
  189.     /* Code Body                                                      */
  190.     /*----------------------------------------------------------------*/
  191.     curr_scr_id = GetExitScrnID();
  192.     return curr_scr_id == SCR_APPMEM_STOP_PROMPT || 
  193.            curr_scr_id == SCR_APPMEM_STOP_PROGRESSING;
  194. }
  197. /*****************************************************************************
  198.  * FUNCTION
  199.  *  mmi_frm_appmem_is_prompt_screens_in_history
  200.  * DESCRIPTION
  201.  *  Whether a prompt screen (SCR_APPMEM_STOP_PROMPT or SCR_APPMEM_STOP_PROGRESSING)
  202.  *  is inside history.
  203.  * PARAMETERS
  204.  *  void
  205.  * RETURNS
  206.  *  MMI_BOOL
  207.  *****************************************************************************/
  208. static MMI_BOOL mmi_frm_appmem_is_prompt_screens_in_history(void)
  209. {
  210.     /*----------------------------------------------------------------*/
  211.     /* Local Variables                                                */
  212.     /*----------------------------------------------------------------*/
  214.     /*----------------------------------------------------------------*/
  215.     /* Code Body                                                      */
  216.     /*----------------------------------------------------------------*/
  217.     return IsScreenPresent(SCR_APPMEM_STOP_PROMPT) || 
  218.            IsScreenPresent(SCR_APPMEM_STOP_PROGRESSING);
  219. }
  222. /*****************************************************************************
  223.  * FUNCTION
  224.  *  mmi_frm_appmem_jump_to_prompt_screen
  225.  * DESCRIPTION
  226.  *  Go back to the prompt screen
  227.  * PARAMETERS
  228.  *  void
  229.  * RETURNS
  230.  *  void
  231.  *****************************************************************************/
  232. static void mmi_frm_appmem_jump_to_prompt_screen(void)
  233. {
  234.     /*----------------------------------------------------------------*/
  235.     /* Local Variables                                                */
  236.     /*----------------------------------------------------------------*/
  238.     /*----------------------------------------------------------------*/
  239.     /* Code Body                                                      */
  240.     /*----------------------------------------------------------------*/
  241.     MMI_ASSERT(IsScreenPresent(SCR_APPMEM_STOP_PROMPT));
  242.     GoBackToHistory(SCR_APPMEM_STOP_PROMPT);
  243. }
  244.  
  246. /*****************************************************************************
  247.  * FUNCTION
  248.  *  mmi_frm_appmem_exit_progressing_screen
  249.  * DESCRIPTION
  250.  *  Exit function of progressing screen 
  251.  * PARAMETERS
  252.  *  void
  253.  * RETURNS
  254.  *  void
  255.  *****************************************************************************/
  256. static void mmi_frm_appmem_exit_progressing_screen(void)
  257. {
  258.     /*----------------------------------------------------------------*/
  259.     /* Local Variables                                                */
  260.     /*----------------------------------------------------------------*/
  261.     history h;
  263.     /*----------------------------------------------------------------*/
  264.     /* Code Body                                                      */
  265.     /*----------------------------------------------------------------*/    
  266.     if (g_mmi_frm_appmem_prompt.keep_prompt_screen_in_history)
  267.     {
  268.         h.scrnID = SCR_APPMEM_STOP_PROGRESSING;
  269.         h.entryFuncPtr = mmi_frm_appmem_entry_progressing_screen;
  270.         pfnUnicodeStrcpy((S8*) h.inputBuffer, (S8*) L"");
  271.         GetCategoryHistory(h.guiBuffer);
  272.     
  273.         AddHistory(h);
  274.     }
  275. }
  278. /*****************************************************************************
  279.  * FUNCTION
  280.  *  mmi_frm_appmem_check_enough_memory
  281.  * DESCRIPTION
  282.  *  Check if the free memory is enough
  283.  * PARAMETERS
  284.  *  void
  285.  * RETURNS
  286.  *  MMI_BOOL
  287.  *****************************************************************************/
  288. static MMI_BOOL mmi_frm_appmem_check_enough_memory(void)
  289. {
  290.     /*----------------------------------------------------------------*/
  291.     /* Local Variables                                                */
  292.     /*----------------------------------------------------------------*/
  294.     /*----------------------------------------------------------------*/
  295.     /* Code Body                                                      */
  296.     /*----------------------------------------------------------------*/
  297.     if (g_mmi_frm_appmem_prompt.require_full_pool && applib_mem_ap_get_alloc_count() == 0)
  298.     {
  299.         return MMI_TRUE;
  300.     }
  302.     if (!g_mmi_frm_appmem_prompt.require_full_pool && 
  303.          applib_mem_ap_get_max_alloc_size() >= g_mmi_frm_appmem_prompt.required_size)
  304.     {
  305.         return MMI_TRUE;
  306.     }
  308.     return MMI_FALSE;
  309. }
  312. /*****************************************************************************
  313.  * FUNCTION
  314.  *  mmi_frm_appmem_entry_progressing_screen
  315.  * DESCRIPTION
  316.  *  Entry function of progressing screen when an application has not finished stopping
  317.  * PARAMETERS
  318.  *  void
  319.  * RETURNS
  320.  *  void
  321.  *****************************************************************************/
  322. static void mmi_frm_appmem_entry_progressing_screen(void)
  323. {
  324.     /*----------------------------------------------------------------*/
  325.     /* Local Variables                                                */
  326.     /*----------------------------------------------------------------*/
  327.     U8 *guiBuffer;
  329.     /*----------------------------------------------------------------*/
  330.     /* Code Body                                                      */
  331.     /*----------------------------------------------------------------*/
  332.     if (mmi_frm_appmem_check_enough_memory() &&
  333.         !is_redrawing_old_screens())    /* not redrawn by small screen */
  334.     {
  335.         DisplayPopupCallBack(
  336.             (U8*) GetString(STR_ID_APPMEM_NOTIFY_STARTING_NEW), 
  337.             IMG_GLOBAL_INFO, 
  338.             0, 
  339.             UI_POPUP_NOTIFYDURATION_TIME_2000, 
  340.             SUCCESS_TONE, 
  341.             mmi_frm_appmem_invoke_release_mem_success_callback);
  342.     }
  343.     else
  344.     {    
  345.         EntryNewScreen(SCR_APPMEM_STOP_PROGRESSING, mmi_frm_appmem_exit_progressing_screen, NULL, NULL);     
  347.         guiBuffer = GetCurrGuiBuffer(SCR_APPMEM_STOP_PROGRESSING);
  349.         ShowCategory8Screen(
  350.             0,
  351.             0,
  352.             0,                                  /* Left softkey */
  353.             0,
  354.             STR_GLOBAL_BACK,                    /* Right softkey */
  355.             0,
  356.             STR_ID_APPMEM_WAITING_FOR_STOP,     /* Message */
  357.             IMG_GLOBAL_PROGRESS,
  358.             guiBuffer);
  359.  
  360.         SetRightSoftkeyFunction(mmi_frm_appmem_jump_to_prompt_screen, KEY_EVENT_UP);
  361.     }
  362. }
  365. /*****************************************************************************
  366.  * FUNCTION
  367.  *  mmi_frm_appmem_stop_confirm_screen_yes
  368.  * DESCRIPTION
  369.  *  User confirm to stop an application
  370.  * PARAMETERS
  371.  *  void
  372.  * RETURNS
  373.  *  void
  374.  *****************************************************************************/
  375. static void mmi_frm_appmem_stop_confirm_screen_yes(void)
  376. {
  377.     /*----------------------------------------------------------------*/
  378.     /* Local Variables                                                */
  379.     /*----------------------------------------------------------------*/
  381.     /*----------------------------------------------------------------*/
  382.     /* Code Body                                                      */
  383.     /*----------------------------------------------------------------*/
  384.     g_mmi_frm_appmem_prompt.stop_state = MMI_FRM_APPMEM_STOP_STATE_WAITING;
  386.     applib_mem_ap_stop_app_by_MMI_task(g_mmi_frm_appmem_prompt.app_id_confirm_to_stop);
  387.     
  388.     if (g_mmi_frm_appmem_prompt.stop_state != MMI_FRM_APPMEM_STOP_STATE_FINISHED)
  389.     {
  390.         /* mmi_frm_appmem_stop_finished_handler() was not invoked inside
  391.            applib_mem_ap_stop_app_by_MMI_task(), we display progressing
  392.            screen to wait for mmi_frm_appmem_stop_finished_handler() */ 
  393.         mmi_frm_appmem_entry_progressing_screen();
  394.     }
  396.     g_mmi_frm_appmem_prompt.stop_state = MMI_FRM_APPMEM_STOP_STATE_IGNORE;    
  398. }
  401. /*****************************************************************************
  402.  * FUNCTION
  403.  *  mmi_frm_appmem_entry_stop_confirm_screen
  404.  * DESCRIPTION
  405.  *  Ask user to confirm to stop application
  406.  * PARAMETERS
  407.  *  void
  408.  * RETURNS
  409.  *  void
  410.  *****************************************************************************/
  411. static void mmi_frm_appmem_entry_stop_confirm_screen(void)
  412. {
  413.     /*----------------------------------------------------------------*/
  414.     /* Local Variables                                                */
  415.     /*----------------------------------------------------------------*/
  417.     /*----------------------------------------------------------------*/
  418.     /* Code Body                                                      */
  419.     /*----------------------------------------------------------------*/
  420.     DisplayConfirm(
  421.         STR_GLOBAL_YES,
  422.         IMG_GLOBAL_YES,
  423.         STR_GLOBAL_NO,
  424.         IMG_GLOBAL_NO,
  425.         (UI_string_type) GetString(STR_ID_APPMEM_STOP),
  426.         IMG_GLOBAL_QUESTION,
  427.         WARNING_TONE);
  429.     SetLeftSoftkeyFunction(mmi_frm_appmem_stop_confirm_screen_yes, KEY_EVENT_UP);
  430.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  431. }
  434. /*****************************************************************************
  435.  * FUNCTION
  436.  *  mmi_frm_appmem_prompt_screen_get_item
  437.  * DESCRIPTION
  438.  *  Callback function to draw the info box of prompt screen
  439.  * PARAMETERS
  440.  *  item_index      [IN]        Index of menu item
  441.  *  str_buff        [OUT]       Output text buffer
  442.  *  img_buff_p      [OUT]       Output image buffer
  443.  *  str_img_mask    [OUT]       (deprecated)
  444.  * RETURNS
  445.  *  Success or not
  446.  *****************************************************************************/
  447. static pBOOL mmi_frm_appmem_prompt_screen_get_item(
  448.                 S32 item_index, 
  449.                 UI_string_type str_buff, 
  450.                 PU8 *img_buff_p, 
  451.                 U8 str_img_mask)
  452. {
  453.     /*----------------------------------------------------------------*/
  454.     /* Local Variables                                                */
  455.     /*----------------------------------------------------------------*/
  456.     applib_mem_ap_usage_struct *applist;
  457.     S8 size_str[32];
  458.     S8 size_str_ucs2[32 * 2];
  459.     S32 app_name_len;
  461.     /*----------------------------------------------------------------*/
  462.     /* Code Body                                                      */
  463.     /*----------------------------------------------------------------*/
  464.     MMI_ASSERT(g_mmi_frm_appmem_prompt_screen &&
  465.                item_index < g_mmi_frm_appmem_prompt_screen->num_app);
  467.     applist = g_mmi_frm_appmem_prompt_screen->applist;
  468.     
  469.     UCS2Strncpy((S8*) str_buff, GetString((U16) applist[item_index].string_id), (MAX_SUB_MENU_SIZE / 2));
  470.     app_name_len = UCS2Strlen((S8*) str_buff);
  472.     if (applist[item_index].is_stopping)
  473.     {
  474.         UCS2Strncpy(
  475.             (S8*) str_buff + (app_name_len * 2), 
  476.             (S8*) GetString(STR_ID_APPMEM_ATTR_STOPPING),
  477.             (MAX_SUB_MENU_SIZE / 2) - app_name_len);
  478.     }
  479.     else
  480.     {
  481.         sprintf((char*) size_str, " (%d K)", applist[item_index].mem_size / 1024);
  482.         AnsiiToUnicodeString(size_str_ucs2, size_str);
  483.         
  484.         UCS2Strncpy(
  485.             (S8*) str_buff + (app_name_len * 2), 
  486.             size_str_ucs2, 
  487.             (MAX_SUB_MENU_SIZE / 2) - app_name_len);
  488.     }
  489.     
  490.     *img_buff_p = (PU8) GetImage((U16) applist[item_index].icon_id);
  492.     return (pBOOL) MMI_TRUE;
  493. }
  496. /*****************************************************************************
  497.  * FUNCTION
  498.  *  mmi_frm_appmem_prompt_screen_init_info
  499.  * DESCRIPTION
  500.  *  Initialize the info box
  501.  * PARAMETERS
  502.  *  void
  503.  * RETURNS
  504.  *  The minimum height of info box
  505.  *****************************************************************************/
  506. static S32 mmi_frm_appmem_prompt_screen_init_info(void)
  507. {
  508.     /*----------------------------------------------------------------*/
  509.     /* Local Variables                                                */
  510.     /*----------------------------------------------------------------*/
  511.     S32 msg_length;
  512.     UI_string_type msg;
  514.     /*----------------------------------------------------------------*/
  515.     /* Code Body                                                      */
  516.     /*----------------------------------------------------------------*/
  517.     msg = (UI_string_type) GetString(STR_ID_APPMEM_PROMPT_STOP_APP);
  518.     msg_length = gui_strlen(msg);
  520.     create_multiline_inputbox_set_buffer(msg, msg_length, msg_length, 0);
  521.     resize_multiline_inputbox(UI_device_width, UI_device_height);
  522.     
  523.     MMI_multiline_inputbox.flags |= UI_MULTI_LINE_INPUT_BOX_DISABLE_CURSOR_DRAW | 
  524.         UI_MULTI_LINE_INPUT_BOX_VIEW_MODE | UI_MULTI_LINE_INPUT_BOX_DISABLE_SCROLLBAR;
  526.     show_multiline_inputbox_no_draw();
  528.     /* Add (get_multiline_inputbox_line_height() / 4) for extra spacing */
  529.     return get_multiline_inputbox_line_height() * MMI_multiline_inputbox.n_lines +
  530.            MMI_multiline_inputbox.text_y + (get_multiline_inputbox_line_height() / 4);
  531. }
  534. /*****************************************************************************
  535.  * FUNCTION
  536.  *  mmi_frm_appmem_prompt_screen_draw_info
  537.  * DESCRIPTION
  538.  *  Callback function to draw the info box of prompt screen
  539.  * PARAMETERS
  540.  *  idx     [IN]    menu item index
  541.  *  x1      [IN]    x of left-top point
  542.  *  y1      [IN]    y of left-top point
  543.  *  x2      [IN]    x of right-bottom point
  544.  *  y2      [IN]    y of right-bottom point
  545.  * RETURNS
  546.  *  void
  547.  *****************************************************************************/
  548. static void mmi_frm_appmem_prompt_screen_draw_info(S32 idx, S32 x1, S32 y1, S32 x2, S32 y2)
  549. {
  550.     /*----------------------------------------------------------------*/
  551.     /* Local Variables                                                */
  552.     /*----------------------------------------------------------------*/
  553.     
  554.     /*----------------------------------------------------------------*/
  555.     /* Code Body                                                      */
  556.     /*----------------------------------------------------------------*/
  557.     move_multiline_inputbox(x1, y1);
  558.     resize_multiline_inputbox(x2 - x1 + 1, y2 - y1 + 1);
  559.     show_multiline_inputbox_no_draw();
  560.     
  561.     show_multiline_inputbox();
  562. }
  565. /*****************************************************************************
  566.  * FUNCTION
  567.  *  mmi_frm_appmem_prompt_screen_hide_info
  568.  * DESCRIPTION
  569.  *  Callback function to hide the info box of prompt screen
  570.  * PARAMETERS
  571.  *  void
  572.  * RETURNS
  573.  *  void
  574.  *****************************************************************************/
  575. static void mmi_frm_appmem_prompt_screen_hide_info(void)
  576. {
  577.     /*----------------------------------------------------------------*/
  578.     /* Local Variables                                                */
  579.     /*----------------------------------------------------------------*/
  581.     /*----------------------------------------------------------------*/
  582.     /* Code Body                                                      */
  583.     /*----------------------------------------------------------------*/
  584.     
  585. }
  588. /*****************************************************************************
  589.  * FUNCTION
  590.  *  mmi_frm_appmem_prompt_screen_stop_highlighted
  591.  * DESCRIPTION
  592.  *  Stop the current highlighted application
  593.  * PARAMETERS
  594.  *  void
  595.  * RETURNS
  596.  *  void
  597.  *****************************************************************************/
  598. static void mmi_frm_appmem_prompt_screen_stop_highlighted(void)
  599. {
  600.     /*----------------------------------------------------------------*/
  601.     /* Local Variables                                                */
  602.     /*----------------------------------------------------------------*/
  603.     S32 highlited_item;
  605.     /*----------------------------------------------------------------*/
  606.     /* Code Body                                                      */
  607.     /*----------------------------------------------------------------*/    
  608.     MMI_ASSERT(GetExitScrnID() == SCR_APPMEM_STOP_PROMPT &&
  609.                g_mmi_frm_appmem_prompt_screen);
  611.     highlited_item = GetHighlightedItem();
  612.     MMI_ASSERT(highlited_item < g_mmi_frm_appmem_prompt_screen->num_app);
  614.     g_mmi_frm_appmem_prompt.app_id_confirm_to_stop = 
  615.         g_mmi_frm_appmem_prompt_screen->applist[highlited_item].app_id;
  617.     mmi_frm_appmem_entry_stop_confirm_screen();
  618. }
  621. /*****************************************************************************
  622.  * FUNCTION
  623.  *  mmi_frm_appmem_prompt_screen_wait_highlighted
  624.  * DESCRIPTION
  625.  *  Wait a stopping application
  626.  * PARAMETERS
  627.  *  void
  628.  * RETURNS
  629.  *  void
  630.  *****************************************************************************/
  631. static void mmi_frm_appmem_prompt_screen_wait_highlighted(void)
  632. {
  633.     /*----------------------------------------------------------------*/
  634.     /* Local Variables                                                */
  635.     /*----------------------------------------------------------------*/
  637.     /*----------------------------------------------------------------*/
  638.     /* Code Body                                                      */
  639.     /*----------------------------------------------------------------*/    
  640.     mmi_frm_appmem_entry_progressing_screen();
  641. }
  644. /*****************************************************************************
  645.  * FUNCTION
  646.  *  mmi_frm_appmem_prompt_screen_highlight_hdlr
  647.  * DESCRIPTION
  648.  *  Highlight handler of prompt screen
  649.  * PARAMETERS
  650.  *  item_index  [IN]    currently highlighted menu index
  651.  * RETURNS
  652.  *  void
  653.  *****************************************************************************/
  654. static void mmi_frm_appmem_prompt_screen_highlight_hdlr(S32 item_index)
  655. {
  656.     /*----------------------------------------------------------------*/
  657.     /* Local Variables                                                */
  658.     /*----------------------------------------------------------------*/
  660.     /*----------------------------------------------------------------*/
  661.     /* Code Body                                                      */
  662.     /*----------------------------------------------------------------*/    
  663.     if (g_mmi_frm_appmem_prompt_screen->num_app == 0)
  664.     {
  665.         return;
  666.     }
  667.     
  668.     MMI_ASSERT(g_mmi_frm_appmem_prompt_screen && 
  669.                item_index < g_mmi_frm_appmem_prompt_screen->num_app);
  670.     
  671.     if (!g_mmi_frm_appmem_prompt_screen->applist[item_index].is_stopping)
  672.     {
  673.         ChangeLeftSoftkey(STR_ID_APPMEM_STOP, 0);
  674.         SetLeftSoftkeyFunction(mmi_frm_appmem_prompt_screen_stop_highlighted, KEY_EVENT_UP);
  675.     }
  676.     else
  677.     {
  678.         ChangeLeftSoftkey(STR_ID_APPMEM_WAIT, 0);
  679.         SetLeftSoftkeyFunction(mmi_frm_appmem_prompt_screen_wait_highlighted, KEY_EVENT_UP);
  680.     }
  681. }
  684. /*****************************************************************************
  685.  * FUNCTION
  686.  *  mmi_frm_appmem_exit_prompt_screen
  687.  * DESCRIPTION
  688.  *  Exit function of prompt screen 
  689.  * PARAMETERS
  690.  *  void
  691.  * RETURNS
  692.  *  void
  693.  *****************************************************************************/
  694. static void mmi_frm_appmem_exit_prompt_screen(void)
  695. {
  696.     /*----------------------------------------------------------------*/
  697.     /* Local Variables                                                */
  698.     /*----------------------------------------------------------------*/
  699.     history h;
  701.     /*----------------------------------------------------------------*/
  702.     /* Code Body                                                      */
  703.     /*----------------------------------------------------------------*/    
  704.     if (g_mmi_frm_appmem_prompt.keep_prompt_screen_in_history)
  705.     {
  706.         h.scrnID = SCR_APPMEM_STOP_PROMPT;
  707.         h.entryFuncPtr = mmi_frm_appmem_entry_prompt_screen;
  708.         pfnUnicodeStrcpy((S8*) h.inputBuffer, (S8*) L"");
  709.         GetCategoryHistory(h.guiBuffer);
  710.     
  711.         AddHistory(h);
  712.     }
  714.     OslMfree(g_mmi_frm_appmem_prompt_screen);
  715.     g_mmi_frm_appmem_prompt_screen = NULL;
  716. }
  719. /*****************************************************************************
  720.  * FUNCTION
  721.  *  mmi_frm_appmem_entry_prompt_screen
  722.  * DESCRIPTION
  723.  *  Entry function of prompt screen to stop other applications
  724.  * PARAMETERS
  725.  *  void
  726.  * RETURNS
  727.  *  void
  728.  *****************************************************************************/
  729. static void mmi_frm_appmem_entry_prompt_screen(void)
  730. {
  731.     /*----------------------------------------------------------------*/
  732.     /* Local Variables                                                */
  733.     /*----------------------------------------------------------------*/
  734.     U8 *guiBuffer;
  735.     S32 info_box_height;
  737.     /*----------------------------------------------------------------*/
  738.     /* Code Body                                                      */
  739.     /*----------------------------------------------------------------*/
  740.     MMI_ASSERT(g_mmi_frm_appmem_prompt_screen == NULL);
  741.     
  742.     if (mmi_frm_appmem_check_enough_memory() && 
  743.         !is_redrawing_old_screens())    /* not redrawn by small screen */
  744.     {
  745.         DisplayPopupCallBack(
  746.             (U8*) GetString(STR_ID_APPMEM_NOTIFY_STARTING_NEW), 
  747.             IMG_GLOBAL_INFO, 
  748.             0, 
  749.             UI_POPUP_NOTIFYDURATION_TIME_2000, 
  750.             SUCCESS_TONE, 
  751.             mmi_frm_appmem_invoke_release_mem_success_callback);
  752.     }
  753.     else
  754.     {
  755.         EntryNewScreen(SCR_APPMEM_STOP_PROMPT, mmi_frm_appmem_exit_prompt_screen, NULL, NULL);     
  757.         guiBuffer = GetCurrGuiBuffer(SCR_APPMEM_STOP_PROMPT);
  759.         g_mmi_frm_appmem_prompt_screen = 
  760.             (mmi_frm_appmem_prompt_screen_struct*) OslMalloc(sizeof(mmi_frm_appmem_prompt_screen_struct));
  762.         g_mmi_frm_appmem_prompt_screen->num_app = 
  763.             (S32) applib_mem_ap_get_current_usage(
  764.                     g_mmi_frm_appmem_prompt_screen->applist,
  765.                     MMI_FRM_APPMEM_MAX_APP_PROMPTED);
  767.         info_box_height = mmi_frm_appmem_prompt_screen_init_info();        
  769.         RegisterHighlightHandler(mmi_frm_appmem_prompt_screen_highlight_hdlr);
  770.         
  771.         ShowCategory211Screen(
  772.             STR_ID_APPMEM_OUT_OF_MEMORY,
  773.             0, 
  774.             STR_ID_APPMEM_STOP,
  775.             0, 
  776.             STR_GLOBAL_BACK, 
  777.             0, 
  778.             g_mmi_frm_appmem_prompt_screen->num_app, 
  779.             mmi_frm_appmem_prompt_screen_get_item, 
  780.             NULL, 
  781.             mmi_frm_appmem_prompt_screen_draw_info,
  782.             mmi_frm_appmem_prompt_screen_hide_info,
  783.             info_box_height,            /* Info box height */
  784.             0,                          /* Background image of info box */
  785.             0,                          /* Highlight item index */
  786.             guiBuffer);
  788.        SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  789.     }
  790. }
  793. /*****************************************************************************
  794.  * FUNCTION
  795.  *  mmi_frm_appmem_invoke_release_mem_success_callback
  796.  * DESCRIPTION
  797.  *  Invoke the calling application there is enough memory
  798.  * PARAMETERS
  799.  *  void
  800.  * RETURNS
  801.  *  void
  802.  *****************************************************************************/
  803. static void mmi_frm_appmem_invoke_release_mem_success_callback(void)
  804. {
  805.     /*----------------------------------------------------------------*/
  806.     /* Local Variables                                                */
  807.     /*----------------------------------------------------------------*/
  809.     /*----------------------------------------------------------------*/
  810.     /* Code Body                                                      */
  811.     /*----------------------------------------------------------------*/
  812.     MMI_ASSERT(mmi_frm_appmem_check_enough_memory());
  813. #ifndef MMI_ON_WIN32
  814.  MMI_ASSERT(mmiapi_is_MMI_task());
  815. #endif
  816.     
  817.     DeleteScreenIfPresent(SCR_APPMEM_STOP_PROMPT);
  818.     DeleteScreenIfPresent(SCR_APPMEM_STOP_PROGRESSING);
  820.     /* Enter another screen by registered callback function */
  821.     g_mmi_frm_appmem_prompt.keep_prompt_screen_in_history = MMI_FALSE;
  822.     g_mmi_frm_appmem_prompt.success_callback();
  824.     /* The callback function must enter new MMI screen */
  825.     MMI_ASSERT(!mmi_frm_appmem_is_in_prompt_screens() &&
  826.                !mmi_frm_appmem_is_prompt_screens_in_history());
  827. }
  830. /*****************************************************************************
  831.  * FUNCTION
  832.  *  mmi_frm_appmem_stop_finished_handler
  833.  * DESCRIPTION
  834.  *  Callback handler when an application finished stop operation
  835.  * PARAMETERS
  836.  *  app_id      [IN]    ID of the application to be stopped
  837.  *  string_id   [IN]    Name of the application to be stopped
  838.  *  result      [IN]    whether the stop operation suceeds or not
  839.  * RETURNS
  840.  *  void
  841.  *****************************************************************************/
  842. static void mmi_frm_appmem_stop_finished_handler(kal_uint32 app_id, kal_uint32 string_id, kal_bool result)
  843. {
  844.     /*----------------------------------------------------------------*/
  845.     /* Local Variables                                                */
  846.     /*----------------------------------------------------------------*/
  848.     /*----------------------------------------------------------------*/
  849.     /* Code Body                                                      */
  850.     /*----------------------------------------------------------------*/
  851.     if (mmi_frm_appmem_is_in_prompt_screens() ||
  852.         g_mmi_frm_appmem_prompt.stop_state == MMI_FRM_APPMEM_STOP_STATE_WAITING) /* In confirm screen */
  853.     {
  854.         U8 *msg;
  855.         U16 icon;
  856.         U8 tone;
  857.         FuncPtr callback;
  858.         if (mmi_frm_appmem_check_enough_memory())
  859.         {
  860.             msg = (U8*) GetString(STR_ID_APPMEM_NOTIFY_STARTING_NEW);
  861.             icon = IMG_GLOBAL_INFO;
  862.             tone = SUCCESS_TONE;        
  863.             callback = mmi_frm_appmem_invoke_release_mem_success_callback;
  864.         }
  865.         else if (result) 
  866.         {
  867.             msg = (U8*) GetString(STR_ID_APPMEM_NOTIFY_STOPPED);
  868.             icon = IMG_GLOBAL_INFO;
  869.             tone = SUCCESS_TONE;
  870.             callback = mmi_frm_appmem_jump_to_prompt_screen;
  871.         }
  872.         else
  873.         {
  874.             msg = (U8*) GetString(STR_ID_APPMEM_NOTIFY_STOP_FAILED);
  875.             icon = IMG_GLOBAL_WARNING;
  876.             tone = ERROR_TONE;
  877.             callback = mmi_frm_appmem_jump_to_prompt_screen;
  878.         }
  879.     
  880.         DisplayPopupCallBack(msg, icon, 0, UI_POPUP_NOTIFYDURATION_TIME_2000, tone, callback);
  882.         if (g_mmi_frm_appmem_prompt.stop_state == MMI_FRM_APPMEM_STOP_STATE_WAITING)
  883.         {
  884.             g_mmi_frm_appmem_prompt.stop_state = MMI_FRM_APPMEM_STOP_STATE_FINISHED;
  885.         }
  886.     }
  887.     else 
  888.     {
  889.         /* 
  890.          * 1. If prompt screen is in history - it will be processed after goback to prompt screen 
  891.          * 2. If prompt screen is not in history - silently ignore the result 
  892.          *    (Maybe it goes back to idle screen)
  893.          */
  894.     }
  895. }
  898. /*****************************************************************************              
  899.  * Extern Global Variable                                                                    
  900.  *****************************************************************************/
  902. /*****************************************************************************              
  903.  * Extern Global Function                                                                    
  904.  *****************************************************************************/
  907. /*****************************************************************************
  908.  * FUNCTION
  909.  *  mmi_frm_appmem_prompt_to_release_mem
  910.  * DESCRIPTION
  911.  *  Show "out-of-memory" screen and prompt user to stop other applications in order 
  912.  *  to release more memory.
  913.  *
  914.  *  Remark: 
  915.  *  1. This function is not suggested to be used in "interrupt screens" 
  916.  *     (e.g. MT call or USB plug-in indication)
  917.  *     Otherwise, it might re-enter the prompt screen and confuse user.
  918.  *  2. 'success_callback' needs to enter a new MMI screen!
  919.  *  3. There is no "failure callback" due to complex interaction of MMI screens.
  920.  *     Applications that use this function should never adopt any explicit or 
  921.  *     implicit "waiting" state for the result.
  922.  *
  923.  *     For example, user may press End key in the "out-of-memory" screen and
  924.  *     try to enter the application again. 
  925.  *
  926.  *  Warning: This function can only be used in MMI task.
  927.  * PARAMETERS
  928.  *  app_name            [IN]    String ID of the application 
  929.  *  app_icon            [IN]    Image ID of the application 
  930.  *  required_size       [IN]    Minimum required memory for the application
  931.  *  success_callback    [IN]    Callback function when getting memory successfully 
  932.  * RETURNS
  933.  *  void
  934.  *****************************************************************************/
  935. void mmi_frm_appmem_prompt_to_release_mem(
  936.         MMI_ID_TYPE app_name, 
  937.         MMI_ID_TYPE app_icon, 
  938.         U32 required_size,
  939.         void (*success_callback)(void))
  940. {
  941.     /*----------------------------------------------------------------*/
  942.     /* Local Variables                                                */
  943.     /*----------------------------------------------------------------*/
  945.     /*----------------------------------------------------------------*/
  946.     /* Code Body                                                      */
  947.     /*----------------------------------------------------------------*/
  948.     MMI_ASSERT(required_size <= applib_mem_ap_get_pool_size());
  950.     /* Avoid reentrance of the prompt screen.
  951.        Application developers should be careful on designing the screen flow */
  952.     MMI_ASSERT(!mmi_frm_appmem_is_in_prompt_screens() && 
  953.                !mmi_frm_appmem_is_prompt_screens_in_history());
  955.     /* Note the context g_mmi_frm_appmem_prompt is not reset  */
  956.     g_mmi_frm_appmem_prompt.app_name = app_name;
  957.     g_mmi_frm_appmem_prompt.app_icon = app_icon;
  958.     g_mmi_frm_appmem_prompt.required_size = required_size;
  959.     g_mmi_frm_appmem_prompt.require_full_pool = MMI_FALSE;    
  960.     g_mmi_frm_appmem_prompt.stop_state = MMI_FRM_APPMEM_STOP_STATE_IGNORE;
  961.     g_mmi_frm_appmem_prompt.keep_prompt_screen_in_history = MMI_TRUE;
  962.     g_mmi_frm_appmem_prompt.success_callback = success_callback;
  964.     mmi_frm_appmem_entry_prompt_screen();
  965. }
  968. /*****************************************************************************
  969.  * FUNCTION
  970.  *  mmi_frm_appmem_prompt_to_release_full_pool
  971.  * DESCRIPTION
  972.  *  Show "out-of-memory" screen and prompt user to stop other applications in order 
  973.  *  to release more memory.
  974.  *  
  975.  *  This function is similar to mmi_frm_appmem_prompt_to_release_mem
  976.  *  but it requires the whole pool.
  977.  *
  978.  *  Warning: This function can only be used in MMI task.
  979.  * PARAMETERS
  980.  *  app_name            [IN]    String ID of the application 
  981.  *  app_icon            [IN]    Image ID of the application 
  982.  *  success_callback    [IN]    Callback function when getting memory successfully 
  983.  * RETURNS
  984.  *  void
  985.  *****************************************************************************/
  986. void mmi_frm_appmem_prompt_to_release_full_pool(
  987.         MMI_ID_TYPE app_name, 
  988.         MMI_ID_TYPE app_icon, 
  989.         void (*success_callback)(void))
  990. {
  991.     /*----------------------------------------------------------------*/
  992.     /* Local Variables                                                */
  993.     /*----------------------------------------------------------------*/
  995.     /*----------------------------------------------------------------*/
  996.     /* Code Body                                                      */
  997.     /*----------------------------------------------------------------*/
  998.     /* Avoid reentrance of the prompt screen.
  999.        Application developers should be careful on designing the screen flow */
  1000.     MMI_ASSERT(!mmi_frm_appmem_is_in_prompt_screens() && 
  1001.                !mmi_frm_appmem_is_prompt_screens_in_history());
  1003.     /* Note the context g_mmi_frm_appmem_prompt is not reset  */
  1004.     g_mmi_frm_appmem_prompt.app_name = app_name;
  1005.     g_mmi_frm_appmem_prompt.app_icon = app_icon;
  1006.     g_mmi_frm_appmem_prompt.required_size = 0;
  1007.     g_mmi_frm_appmem_prompt.require_full_pool = MMI_TRUE;
  1008.     g_mmi_frm_appmem_prompt.stop_state = MMI_FRM_APPMEM_STOP_STATE_IGNORE;
  1009.     g_mmi_frm_appmem_prompt.keep_prompt_screen_in_history = MMI_TRUE;
  1010.     g_mmi_frm_appmem_prompt.success_callback = success_callback;
  1012.     mmi_frm_appmem_entry_prompt_screen();
  1013. }
  1016. /*****************************************************************************
  1017.  * FUNCTION
  1018.  *  mmi_frm_appmem_init
  1019.  * DESCRIPTION
  1020.  *  Initialize app-based ASM.
  1021.  * PARAMETERS
  1022.  *  void
  1023.  * RETURNS
  1024.  *  void
  1025.  *****************************************************************************/
  1026. void mmi_frm_appmem_init(void)
  1027. {
  1028.     /*----------------------------------------------------------------*/
  1029.     /* Local Variables                                                */
  1030.     /*----------------------------------------------------------------*/
  1032.     /*----------------------------------------------------------------*/
  1033.     /* Code Body                                                      */
  1034.     /*----------------------------------------------------------------*/
  1035.     applib_mem_ap_init(mmi_frm_appmem_stop_finished_handler);
  1036. }
  1039. /***************************************************************************** 
  1040.  * Unit Test 
  1041.  *****************************************************************************/
  1043. #ifdef APPLIB_MEM_UNIT_TEST
  1045. #define MMI_FRM_APPMEM_TEST1_SIZE   (60*1024)
  1047. #define MMI_FRM_APPMEM_TEST2_SIZE   (30*1024)
  1049. #define MMI_FRM_APPMEM_TEST3_SIZE   (100*1024)
  1051. #define MMI_FRM_APPMEM_TEST4_SIZE   (25*1024)
  1053. #define MMI_FRM_APPMEM_TEST5_SIZE   (40*1024)
  1055. #include "stdlib.h"
  1057. /*****************************************************************************
  1058.  * FUNCTION
  1059.  *  mmi_frm_appmem_unit_test_stress_alloc
  1060.  * DESCRIPTION
  1061.  *  Unit test routine
  1062.  * PARAMETERS
  1063.  *  void
  1064.  * RETURNS
  1065.  *  void
  1066.  *****************************************************************************/
  1067. static void mmi_frm_appmem_unit_test_stress_alloc(void)
  1068. {
  1069.     /*----------------------------------------------------------------*/
  1070.     /* Local Variables                                                */
  1071.     /*----------------------------------------------------------------*/
  1072.     kal_uint32 *ptr_list[100];
  1073.     kal_int32 i, count, free_space_original, tmp;
  1075.     /*----------------------------------------------------------------*/
  1076.     /* Code Body                                                      */
  1077.     /*----------------------------------------------------------------*/
  1078.     applib_mem_ap_free_all(APPLIB_MEM_AP_ID_TEST1);
  1079.     applib_mem_ap_free_all(APPLIB_MEM_AP_ID_TEST2);
  1080.     applib_mem_ap_free_all(APPLIB_MEM_AP_ID_TEST3);
  1081.     applib_mem_ap_free_all(APPLIB_MEM_AP_ID_TEST4);
  1082.     applib_mem_ap_free_all(APPLIB_MEM_AP_ID_TEST5);    
  1084.     free_space_original = applib_mem_ap_get_total_left_size();
  1086. #define ALLOC_SIZE(_idx)    ((_idx) + (_idx) * 256)
  1087. #define PTR_LIST_SIZE       (sizeof(ptr_list) / sizeof(void*))
  1089.     for (i = 0; i < PTR_LIST_SIZE; i++)
  1090.     {
  1091.         if ((ptr_list[i] = applib_mem_ap_alloc(APPLIB_MEM_AP_ID_TEST1, ALLOC_SIZE(i))) == NULL)
  1092.         {
  1093.             MMI_ASSERT(applib_mem_ap_get_max_alloc_size() < ALLOC_SIZE(i));
  1094.             break;
  1095.         }
  1096.     }
  1098.     count = i;
  1099.     MMI_ASSERT(count > 0);
  1100.     MMI_ASSERT(applib_mem_ap_get_alloc_count() == count);
  1102.     applib_mem_ap_check_integrity();
  1104.     tmp = 0;
  1105.     for (i = 0; i < count; i += 2)
  1106.     {
  1107.         tmp += ALLOC_SIZE(i);
  1108.         applib_mem_ap_free(ptr_list[i]);
  1109.     }
  1111. #ifndef MMI_ON_WIN32
  1112.     MMI_ASSERT(tmp < free_space_original - applib_mem_ap_get_total_left_size());
  1113. #endif
  1115.     applib_mem_ap_check_integrity();
  1117.     if (count >= 2)
  1118.     {
  1119.         for (i = 1; i < count; i += 2)
  1120.         {
  1121.             MMI_ASSERT(applib_mem_ap_is_valid_block(ptr_list[i]));
  1122.         }
  1123.     }
  1125.     applib_mem_ap_free_all(APPLIB_MEM_AP_ID_TEST2);
  1127.     applib_mem_ap_check_integrity();
  1129.     applib_mem_ap_free_all(APPLIB_MEM_AP_ID_TEST1);
  1131.     applib_mem_ap_check_integrity();
  1133.     MMI_ASSERT(free_space_original == applib_mem_ap_get_total_left_size());
  1134.     MMI_ASSERT(applib_mem_ap_get_alloc_count() == 0);    
  1136.     /* Random alloc/free */
  1138.     for (i = 0; i < PTR_LIST_SIZE; i++)
  1139.     {
  1140.         ptr_list[i] = NULL;
  1141.     }
  1143.     for (;;)
  1144.     {
  1145.         kal_int32 key = rand();
  1146.         if ((key % 1000) == 0)
  1147.         {
  1148.             break;
  1149.         }
  1150.         
  1151.         if (applib_mem_ap_get_alloc_count() == PTR_LIST_SIZE || key % 3 == 0)
  1152.         {
  1153.             i = ((key + 1) % PTR_LIST_SIZE);
  1154.             for (; i != key % PTR_LIST_SIZE; i++, i %= PTR_LIST_SIZE)
  1155.             {
  1156.                 if (ptr_list[i])
  1157.                 {
  1158.                     applib_mem_ap_free(ptr_list[i]);
  1159.                     ptr_list[i] = NULL;
  1160.                     break;
  1161.                 }
  1162.             }
  1163.         }
  1164.         else
  1165.         {
  1166.             for (i = 0; i < PTR_LIST_SIZE; i++)
  1167.             {
  1168.                 if (!ptr_list[i])
  1169.                 {
  1170.                     kal_uint32 size = key % applib_mem_ap_get_pool_size();
  1171.                     ptr_list[i] = applib_mem_ap_alloc(APPLIB_MEM_AP_ID_TEST1 + (key % 5), size);
  1172.                     /* Test memory corruption detection */
  1173.                     // ptr_list[i][size/4] = 1;
  1174.                     // ptr_list[i][size/4 + 1] = 1;
  1175.                     // ptr_list[i][size/4 + 2] = 1;
  1176.                     break;
  1177.                 }
  1178.             }
  1179.         }
  1180.         applib_mem_ap_check_integrity();
  1181.     }
  1183.     applib_mem_ap_free_all(APPLIB_MEM_AP_ID_TEST1);
  1184.     applib_mem_ap_free_all(APPLIB_MEM_AP_ID_TEST2);
  1185.     applib_mem_ap_free_all(APPLIB_MEM_AP_ID_TEST3);
  1186.     applib_mem_ap_free_all(APPLIB_MEM_AP_ID_TEST4);
  1187.     applib_mem_ap_free_all(APPLIB_MEM_AP_ID_TEST5);    
  1188.     MMI_ASSERT(free_space_original == applib_mem_ap_get_total_left_size());
  1189.     MMI_ASSERT(applib_mem_ap_get_alloc_count() == 0);
  1190. }
  1193. static void mmi_frm_appmem_unit_test_stop_1_timer_hdlr(void)
  1194. {
  1195.     /*----------------------------------------------------------------*/
  1196.     /* Local Variables                                                */
  1197.     /*----------------------------------------------------------------*/
  1199.     /*----------------------------------------------------------------*/
  1200.     /* Code Body                                                      */
  1201.     /*----------------------------------------------------------------*/
  1202.     applib_mem_ap_free_all(APPLIB_MEM_AP_ID_TEST1);    
  1203.     applib_mem_ap_notify_stop_finished(APPLIB_MEM_AP_ID_TEST1, KAL_TRUE);
  1204. }
  1207. static void mmi_frm_appmem_unit_test_stop_1(void)
  1208. {
  1209.     /*----------------------------------------------------------------*/
  1210.     /* Local Variables                                                */
  1211.     /*----------------------------------------------------------------*/
  1213.     /*----------------------------------------------------------------*/
  1214.     /* Code Body                                                      */
  1215.     /*----------------------------------------------------------------*/
  1216.     StartTimer(FM_AUTO_TEST_COMMNON_TIMER, 10000, mmi_frm_appmem_unit_test_stop_1_timer_hdlr);
  1217. }
  1220. static void mmi_frm_appmem_unit_test_stop_2_timer_hdlr(void)
  1221. {
  1222.     /*----------------------------------------------------------------*/
  1223.     /* Local Variables                                                */
  1224.     /*----------------------------------------------------------------*/
  1226.     /*----------------------------------------------------------------*/
  1227.     /* Code Body                                                      */
  1228.     /*----------------------------------------------------------------*/
  1229.     applib_mem_ap_free_all(APPLIB_MEM_AP_ID_TEST2);
  1230.     applib_mem_ap_notify_stop_finished(APPLIB_MEM_AP_ID_TEST2, KAL_TRUE);
  1231. }
  1234. static void mmi_frm_appmem_unit_test_stop_2(void)
  1235. {
  1236.     /*----------------------------------------------------------------*/
  1237.     /* Local Variables                                                */
  1238.     /*----------------------------------------------------------------*/
  1240.     /*----------------------------------------------------------------*/
  1241.     /* Code Body                                                      */
  1242.     /*----------------------------------------------------------------*/
  1243.     StartTimer(FM_AUTO_TEST_COMMNON_TIMER, 300, mmi_frm_appmem_unit_test_stop_2_timer_hdlr);
  1244. }
  1247. static void mmi_frm_appmem_unit_test_stop_3_timer_hdlr(void)
  1248. {
  1249.     /*----------------------------------------------------------------*/
  1250.     /* Local Variables                                                */
  1251.     /*----------------------------------------------------------------*/
  1253.     /*----------------------------------------------------------------*/
  1254.     /* Code Body                                                      */
  1255.     /*----------------------------------------------------------------*/
  1256.     applib_mem_ap_free_all(APPLIB_MEM_AP_ID_TEST3);    
  1257.     applib_mem_ap_notify_stop_finished(APPLIB_MEM_AP_ID_TEST3, KAL_TRUE);
  1258. }
  1261. static void mmi_frm_appmem_unit_test_stop_3(void)
  1262. {
  1263.     /*----------------------------------------------------------------*/
  1264.     /* Local Variables                                                */
  1265.     /*----------------------------------------------------------------*/
  1267.     /*----------------------------------------------------------------*/
  1268.     /* Code Body                                                      */
  1269.     /*----------------------------------------------------------------*/
  1270.     StartTimer(FM_AUTO_TEST_COMMNON_TIMER, 3000, mmi_frm_appmem_unit_test_stop_3_timer_hdlr);
  1271. }
  1274. static void mmi_frm_appmem_unit_test_stop_4(void)
  1275. {
  1276.     /*----------------------------------------------------------------*/
  1277.     /* Local Variables                                                */
  1278.     /*----------------------------------------------------------------*/
  1280.     /*----------------------------------------------------------------*/
  1281.     /* Code Body                                                      */
  1282.     /*----------------------------------------------------------------*/
  1283.     applib_mem_ap_free_all(APPLIB_MEM_AP_ID_TEST4);        
  1284.     /* Return immediately */   
  1285.     applib_mem_ap_notify_stop_finished(APPLIB_MEM_AP_ID_TEST4, KAL_TRUE);
  1286. }
  1289. static void mmi_frm_appmem_unit_test_stop_5(void)
  1290. {
  1291.     /*----------------------------------------------------------------*/
  1292.     /* Local Variables                                                */
  1293.     /*----------------------------------------------------------------*/
  1295.     /*----------------------------------------------------------------*/
  1296.     /* Code Body                                                      */
  1297.     /*----------------------------------------------------------------*/
  1298.     /* Return immediately */
  1299.     applib_mem_ap_notify_stop_finished(APPLIB_MEM_AP_ID_TEST5, KAL_FALSE); /* Fail */
  1300. }
  1302. /*****************************************************************************
  1303.  * FUNCTION
  1304.  *  mmi_frm_appmem_unit_test_success_callback1
  1305.  * DESCRIPTION
  1306.  *  Callback function when memory was released.
  1307.  * PARAMETERS
  1308.  *  void
  1309.  * RETURNS
  1310.  *  void
  1311.  *****************************************************************************/
  1312. static void (*g_mmi_frm_appmem_unit_test_run_callback1)(void);
  1314. static void mmi_frm_appmem_unit_test_success_callback1(void)
  1315. {
  1316.     void *ptr = applib_mem_ap_alloc(APPLIB_MEM_AP_ID_TEST1, MMI_FRM_APPMEM_TEST1_SIZE);
  1317.     MMI_ASSERT(ptr);
  1318.     g_mmi_frm_appmem_unit_test_run_callback1();
  1319. }
  1322. /*****************************************************************************
  1323.  * FUNCTION
  1324.  *  mmi_frm_appmem_unit_test_prepare_to_enter_test1
  1325.  * DESCRIPTION
  1326.  *  Simple program to test screen-based ASM
  1327.  * PARAMETERS
  1328.  *  void
  1329.  * RETURNS
  1330.  *  void
  1331.  *****************************************************************************/
  1332. void mmi_frm_appmem_unit_test_prepare_to_enter_test1(void (*run_callback)(void))
  1333. {
  1334.     /*----------------------------------------------------------------*/
  1335.     /* Local Variables                                                */
  1336.     /*----------------------------------------------------------------*/
  1337.     
  1338.     /*----------------------------------------------------------------*/
  1339.     /* Code Body                                                      */
  1340.     /*----------------------------------------------------------------*/
  1341.     applib_mem_ap_free_all(APPLIB_MEM_AP_ID_TEST1);
  1342.     g_mmi_frm_appmem_unit_test_run_callback1 = run_callback;
  1343.     if (applib_mem_ap_alloc(APPLIB_MEM_AP_ID_TEST1, MMI_FRM_APPMEM_TEST1_SIZE))
  1344.     {
  1345.         run_callback();
  1346.     }
  1347.     else
  1348.     {
  1349.         mmi_frm_appmem_prompt_to_release_mem(
  1350.             APPLIB_MEM_AP_ID_TEST1,
  1351.             IMG_GLOBAL_L1,
  1352.             MMI_FRM_APPMEM_TEST1_SIZE,
  1353.             mmi_frm_appmem_unit_test_success_callback1);
  1354.     }
  1355. }
  1358. /*****************************************************************************
  1359.  * FUNCTION
  1360.  *  mmi_frm_appmem_unit_test_success_callback2
  1361.  * DESCRIPTION
  1362.  *  Callback function when memory was released.
  1363.  * PARAMETERS
  1364.  *  void
  1365.  * RETURNS
  1366.  *  void
  1367.  *****************************************************************************/
  1368. static void (*g_mmi_frm_appmem_unit_test_run_callback2)(void);
  1370. static void mmi_frm_appmem_unit_test_success_callback2(void)
  1371. {
  1372.     void *ptr = applib_mem_ap_alloc(APPLIB_MEM_AP_ID_TEST2, MMI_FRM_APPMEM_TEST2_SIZE);
  1373.     MMI_ASSERT(ptr);
  1374.     g_mmi_frm_appmem_unit_test_run_callback2();
  1375. }
  1378. /*****************************************************************************
  1379.  * FUNCTION
  1380.  *  mmi_frm_appmem_unit_test_prepare_to_enter_test2
  1381.  * DESCRIPTION
  1382.  *  Simple program to test screen-based ASM
  1383.  * PARAMETERS
  1384.  *  void
  1385.  * RETURNS
  1386.  *  void
  1387.  *****************************************************************************/
  1388. void mmi_frm_appmem_unit_test_prepare_to_enter_test2(void (*run_callback)(void))
  1389. {
  1390.     /*----------------------------------------------------------------*/
  1391.     /* Local Variables                                                */
  1392.     /*----------------------------------------------------------------*/
  1393.     
  1394.     /*----------------------------------------------------------------*/
  1395.     /* Code Body                                                      */
  1396.     /*----------------------------------------------------------------*/
  1397.     applib_mem_ap_free_all(APPLIB_MEM_AP_ID_TEST2);
  1398.     g_mmi_frm_appmem_unit_test_run_callback2 = run_callback;    
  1399.     if (applib_mem_ap_alloc(APPLIB_MEM_AP_ID_TEST2, MMI_FRM_APPMEM_TEST2_SIZE))
  1400.     {
  1401.         run_callback();
  1402.     }
  1403.     else
  1404.     {
  1405.         mmi_frm_appmem_prompt_to_release_mem(
  1406.             APPLIB_MEM_AP_ID_TEST2,
  1407.             IMG_GLOBAL_L2,
  1408.             MMI_FRM_APPMEM_TEST2_SIZE,
  1409.             mmi_frm_appmem_unit_test_success_callback2);
  1410.     }
  1411. }
  1414. /*****************************************************************************
  1415.  * FUNCTION
  1416.  *  mmi_frm_appmem_unit_test_success_callback3
  1417.  * DESCRIPTION
  1418.  *  Callback function when memory was released.
  1419.  * PARAMETERS
  1420.  *  void
  1421.  * RETURNS
  1422.  *  void
  1423.  *****************************************************************************/
  1424. static void (*g_mmi_frm_appmem_unit_test_run_callback3)(void);
  1426. static void mmi_frm_appmem_unit_test_success_callback3(void)
  1427. {
  1428.     void *ptr = applib_mem_ap_alloc(APPLIB_MEM_AP_ID_TEST3, MMI_FRM_APPMEM_TEST3_SIZE);
  1429.     MMI_ASSERT(ptr);
  1430.     g_mmi_frm_appmem_unit_test_run_callback3();
  1431. }
  1434. /*****************************************************************************
  1435.  * FUNCTION
  1436.  *  mmi_frm_appmem_unit_test_prepare_to_enter_test3
  1437.  * DESCRIPTION
  1438.  *  Simple program to test screen-based ASM
  1439.  * PARAMETERS
  1440.  *  void
  1441.  * RETURNS
  1442.  *  void
  1443.  *****************************************************************************/
  1444. void mmi_frm_appmem_unit_test_prepare_to_enter_test3(void (*run_callback)(void))
  1445. {
  1446.     /*----------------------------------------------------------------*/
  1447.     /* Local Variables                                                */
  1448.     /*----------------------------------------------------------------*/
  1449.     
  1450.     /*----------------------------------------------------------------*/
  1451.     /* Code Body                                                      */
  1452.     /*----------------------------------------------------------------*/
  1453.     applib_mem_ap_free_all(APPLIB_MEM_AP_ID_TEST3);
  1454.     g_mmi_frm_appmem_unit_test_run_callback3 = run_callback;    
  1455.     if (applib_mem_ap_alloc(APPLIB_MEM_AP_ID_TEST3, MMI_FRM_APPMEM_TEST3_SIZE))
  1456.     {
  1457.         run_callback();
  1458.     }
  1459.     else
  1460.     {
  1461.         mmi_frm_appmem_prompt_to_release_mem(
  1462.             APPLIB_MEM_AP_ID_TEST3,
  1463.             IMG_GLOBAL_L3,
  1464.             MMI_FRM_APPMEM_TEST3_SIZE,
  1465.             mmi_frm_appmem_unit_test_success_callback3);
  1466.     }
  1467. }
  1470. /*****************************************************************************
  1471.  * FUNCTION
  1472.  *  mmi_frm_appmem_unit_test_success_callback4
  1473.  * DESCRIPTION
  1474.  *  Callback function when memory was released.
  1475.  * PARAMETERS
  1476.  *  void
  1477.  * RETURNS
  1478.  *  void
  1479.  *****************************************************************************/
  1480. static void (*g_mmi_frm_appmem_unit_test_run_callback4)(void);
  1482. static void mmi_frm_appmem_unit_test_success_callback4(void)
  1483. {
  1484.     void *ptr = applib_mem_ap_alloc(APPLIB_MEM_AP_ID_TEST4, MMI_FRM_APPMEM_TEST4_SIZE);
  1485.     MMI_ASSERT(ptr);
  1486.     g_mmi_frm_appmem_unit_test_run_callback4();
  1487. }
  1490. /*****************************************************************************
  1491.  * FUNCTION
  1492.  *  mmi_frm_appmem_unit_test_prepare_to_enter_test4
  1493.  * DESCRIPTION
  1494.  *  Simple program to test screen-based ASM
  1495.  * PARAMETERS
  1496.  *  void
  1497.  * RETURNS
  1498.  *  void
  1499.  *****************************************************************************/
  1500. void mmi_frm_appmem_unit_test_prepare_to_enter_test4(void (*run_callback)(void))
  1501. {
  1502.     /*----------------------------------------------------------------*/
  1503.     /* Local Variables                                                */
  1504.     /*----------------------------------------------------------------*/
  1505.     
  1506.     /*----------------------------------------------------------------*/
  1507.     /* Code Body                                                      */
  1508.     /*----------------------------------------------------------------*/
  1509.     applib_mem_ap_free_all(APPLIB_MEM_AP_ID_TEST4);
  1510.     g_mmi_frm_appmem_unit_test_run_callback4 = run_callback;    
  1511.     if (applib_mem_ap_alloc(APPLIB_MEM_AP_ID_TEST4, MMI_FRM_APPMEM_TEST4_SIZE))
  1512.     {
  1513.         run_callback();
  1514.     }
  1515.     else
  1516.     {
  1517.         mmi_frm_appmem_prompt_to_release_mem(
  1518.             APPLIB_MEM_AP_ID_TEST4,
  1519.             IMG_GLOBAL_L4,
  1520.             MMI_FRM_APPMEM_TEST4_SIZE,
  1521.             mmi_frm_appmem_unit_test_success_callback4);
  1522.     }
  1523. }
  1526. /*****************************************************************************
  1527.  * FUNCTION
  1528.  *  mmi_frm_appmem_unit_test_success_callback5
  1529.  * DESCRIPTION
  1530.  *  Callback function when memory was released.
  1531.  * PARAMETERS
  1532.  *  void
  1533.  * RETURNS
  1534.  *  void
  1535.  *****************************************************************************/
  1536. static void (*g_mmi_frm_appmem_unit_test_run_callback5)(void);
  1538. static void mmi_frm_appmem_unit_test_success_callback5(void)
  1539. {
  1540.     void *ptr = applib_mem_ap_alloc(APPLIB_MEM_AP_ID_TEST5, MMI_FRM_APPMEM_TEST5_SIZE);
  1541.     MMI_ASSERT(ptr);
  1542.     g_mmi_frm_appmem_unit_test_run_callback5();
  1543. }
  1546. /*****************************************************************************
  1547.  * FUNCTION
  1548.  *  mmi_frm_appmem_unit_test_prepare_to_enter_test5
  1549.  * DESCRIPTION
  1550.  *  Simple program to test screen-based ASM
  1551.  * PARAMETERS
  1552.  *  void
  1553.  * RETURNS
  1554.  *  void
  1555.  *****************************************************************************/
  1556. void mmi_frm_appmem_unit_test_prepare_to_enter_test5(void (*run_callback)(void))
  1557. {
  1558.     /*----------------------------------------------------------------*/
  1559.     /* Local Variables                                                */
  1560.     /*----------------------------------------------------------------*/
  1561.     
  1562.     /*----------------------------------------------------------------*/
  1563.     /* Code Body                                                      */
  1564.     /*----------------------------------------------------------------*/
  1565.     applib_mem_ap_free_all(APPLIB_MEM_AP_ID_TEST5);
  1566.     g_mmi_frm_appmem_unit_test_run_callback5 = run_callback;    
  1567.     if (applib_mem_ap_alloc(APPLIB_MEM_AP_ID_TEST5, MMI_FRM_APPMEM_TEST5_SIZE))
  1568.     {
  1569.         run_callback();
  1570.     }
  1571.     else
  1572.     {
  1573.         mmi_frm_appmem_prompt_to_release_mem(
  1574.             APPLIB_MEM_AP_ID_TEST5,
  1575.             IMG_GLOBAL_L5,
  1576.             MMI_FRM_APPMEM_TEST5_SIZE,
  1577.             mmi_frm_appmem_unit_test_success_callback5);
  1578.     }
  1579. }
  1582. /*****************************************************************************
  1583.  * FUNCTION
  1584.  *  mmi_frm_appmem_unit_test_setup_environment
  1585.  * DESCRIPTION
  1586.  *  Setup environment for unit test of app-based ASM 
  1587.  * PARAMETERS
  1588.  *  void
  1589.  * RETURNS
  1590.  *  void
  1591.  *****************************************************************************/
  1592. void mmi_frm_appmem_unit_test_setup_environment(void)
  1593. {
  1594.     /*----------------------------------------------------------------*/
  1595.     /* Local Variables                                                */
  1596.     /*----------------------------------------------------------------*/
  1597.     static MMI_BOOL first_time = MMI_TRUE;
  1598.     
  1599.     /*----------------------------------------------------------------*/
  1600.     /* Code Body                                                      */
  1601.     /*----------------------------------------------------------------*/
  1602.     if (first_time)
  1603.     {
  1604.         first_time = MMI_FALSE;
  1605.         
  1606.         applib_mem_ap_register(
  1607.             APPLIB_MEM_AP_ID_TEST1, 
  1608.             STR_GLOBAL_1, 
  1609.             IMG_GLOBAL_L1, 
  1610.             mmi_frm_appmem_unit_test_stop_1);
  1611.         applib_mem_ap_register(
  1612.             APPLIB_MEM_AP_ID_TEST2, 
  1613.             STR_GLOBAL_2, 
  1614.             IMG_GLOBAL_L2, 
  1615.             mmi_frm_appmem_unit_test_stop_2);
  1616.         applib_mem_ap_register(
  1617.             APPLIB_MEM_AP_ID_TEST3, 
  1618.             STR_GLOBAL_3, 
  1619.             IMG_GLOBAL_L3, 
  1620.             mmi_frm_appmem_unit_test_stop_3);
  1621.         applib_mem_ap_register(
  1622.             APPLIB_MEM_AP_ID_TEST4, 
  1623.             STR_GLOBAL_4, 
  1624.             IMG_GLOBAL_L4, 
  1625.             mmi_frm_appmem_unit_test_stop_4);
  1626.         applib_mem_ap_register(
  1627.             APPLIB_MEM_AP_ID_TEST5, 
  1628.             STR_GLOBAL_5, 
  1629.             IMG_GLOBAL_L5, 
  1630.             mmi_frm_appmem_unit_test_stop_5);
  1631.     }
  1633.     mmi_frm_appmem_unit_test_stress_alloc();
  1634. }
  1637. #endif /* APPLIB_MEM_UNIT_TEST */