Cosmos 关机情况下来闹钟后增加是否开机选择功能

在关机情况下，来闹钟，点击停止后，增加一个是否开机提示界面，如果点击是，就正常开机；如果点击否，就关机。 此功能在Pluto版本上有，但Cosmos 版本上原始设计没有支持这个功能，如果需要支持，参考下面代码修改即可。
[SOLUTION]
下面的代码在Cosmos MMI 11A1112MP上验证通过。
实现几大步骤：
一，定义控制宏
二，增加 m_isStopPress 来设置 是否需要开机提醒；
三，添加开机提醒的pop框处理；
四，确认相关代码


一，定义控制宏
1. 
定义此功能的宏在 mmi_features.h
#ifndef ALARM_ASK_PWRON
#define ALARM_ASK_PWRON
#endif




二，增加 m_isStopPress 来设置 是否需要开机提醒；
1，
定义m_isStopPress
class VappAlarmIndicationPopup : public VfxBasePopup
{
......
            VfxBool m_isTonePlaying;
#ifdef ALARM_ASK_PWRON
    VfxBool m_isStopPress;
#endif
};
2,
初始化 m_isStopPress
VappAlarmIndicationPopup::VappAlarmIndicationPopup(const VfxU8 &index) : 
    m_clock(NULL),
    m_label(NULL),
    m_btnStop(NULL),
    m_btnSnooze(NULL),
    m_index(index),
    m_isUsrAction(VFX_FALSE),
    m_isTonePlaying(VFX_FALSE)
#ifdef ALARM_ASK_PWRON
    ,m_isStopPress(VFX_FALSE)
#endif
{
}
3，
给 m_isStopPress 赋值
void VappAlarmIndicationPopup::onBtnClick(VfxObject* obj, VfxId id)
{
    m_isUsrAction = VFX_TRUE;
    
    MMI_TRACE(ALM_TRC_GRP, VAPP_ALM_IND_BTN_CLICK, id);
    switch(id)
    {
        case VAPP_ALARM_POP_STOP:
        {
            srv_alm_node_type *node = (srv_alm_node_type *)srv_alm_read(m_index);
            VFX_ASSERT(node != NULL);
            if (node->Freq == SRV_REMINDER_REPEAT_ONCE)
            {
                node->State = 0;
            }
            node->Snooze = 0;
            node->timestamp = ALARM_GET_TIMESTAMP;
            
            srv_alm_write(m_index, node);
        #ifdef ALARM_ASK_PWRON
            m_isStopPress = VFX_TRUE;
        #endif
            break;
        }
        
        case VAPP_ALARM_POP_SNOOZE:
        {
            srv_alm_node_type *node = (srv_alm_node_type *)srv_alm_read(m_index);
            VFX_ASSERT(node != NULL);
            node->Snooze++;
            node->SnoozeInterval = m_snooze;
            node->timestamp = ALARM_GET_TIMESTAMP;
            srv_alm_write(m_index, node);
            VfxS8 snoozeIndex = ALARM_GET_SNOOZE_IDX(m_snooze);
            if (!VappAlarmApp::needPwrOff())
            {
                mmi_frm_nmgr_balloon(
                        MMI_SCENARIO_ID_GENERAL,
                        MMI_EVENT_INFO_BALLOON,
                        MMI_NMGR_BALLOON_TYPE_INFO,
                        (WCHAR*)GetString(ALARM_GET_SNOOZING_FOR_RES(snoozeIndex)));
            }
            
            MMI_TRACE(ALM_TRC_GRP, VAPP_ALM_IND_BTN_CLICK_SNOOZE, node->Snooze);
        #ifdef ALARM_ASK_PWRON
            m_isStopPress = VFX_FALSE;
        #endif
            break;
        }
    }
    
    VappAlarmApp::refreshStatusIcon();
    
    m_signalBtnClick.postEmit(this, id);
    leave(VFX_TRUE);
}
4，
根据 m_isStopPress 的值设置 srv_reminder_notify_finish 的值
void VappAlarmIndicationPopup::onDeinit(void)
{
    MMI_TRACE(ALM_TRC_GRP, VAPP_ALM_IND_DEINIT);
    if (m_isTonePlaying)
    {
        mdi_audio_resume_background_play();
        m_isTonePlaying = VFX_FALSE;
    }
    if (!m_isUsrAction)
    {
        VfxId id;
        
        if (m_btnSnooze != NULL)
        {
            id = VAPP_ALARM_POP_SNOOZE;
        }
        else
        {
            id = VAPP_ALARM_POP_STOP;
        }
        
        onBtnClick(m_btnSnooze, id);
    }
    
    mmi_frm_end_scenario(MMI_SCENARIO_ID_REMINDER_ALARM);
    deregEvtHdlr();
#ifndef ALARM_ASK_PWRON
    srv_reminder_notify_finish(MMI_FALSE);
#else         
    if(m_isStopPress)
    {
        srv_reminder_notify_finish(MMI_TRUE);
    }    
    else
    {
        srv_reminder_notify_finish(MMI_FALSE);
    }
#endif
    VfxBasePopup::onDeinit();
}


三，添加开机提醒的pop框处理；
1.
调用：VappAlarmIndApp::onPowerOnConfirm(evt);
mmi_ret vapp_alarm_evt_handlr(mmi_event_struct *evt)
{
    switch(evt->evt_id)
    {
        case EVT_ID_SRV_REMINDER_NOTIFY:
            VappAlarmIndApp::onReminderEvt(evt);
            break;
            
        case EVT_ID_SRV_REMINDER_PWRRESET_REQ:
        #ifndef ALARM_ASK_PWRON
            VappAlarmApp::onPwroffAsk(evt);
        #else
            VappAlarmIndApp::onPowerOnConfirm(evt);
        #endif
            break;
            
        case EVT_ID_SRV_FMGR_NOTIFICATION_ADV_ACTION:
            VappAlarmApp::onFmgrEvtAdv(evt);
            break;
            
        case EVT_ID_SRV_FMGR_NOTIFICATION_FORMAT:
            VappAlarmApp::onFmgrEvtFormat(evt);
            break;
            
        default:
            break;
    }
    
    return MMI_RET_OK;
}
2.
定义：static mmi_ret onPowerOnConfirm(mmi_event_struct *evt);
class VappAlarmIndApp : public VfxApp
{
    VFX_DECLARE_CLASS(VappAlarmIndApp);
public:
    VappAlarmIndApp(){}
    ~VappAlarmIndApp(){};
// Override
protected:
    void onRun(void* args, VfxU32 argSize);
// Static
public:
    static mmi_ret onReminderEvt(mmi_event_struct *evt);
    static MMI_BOOL onNmgrNotify(mmi_scenario_id scen_id, void *arg);
#ifdef ALARM_ASK_PWRON
    static mmi_ret onPowerOnConfirm(mmi_event_struct *evt);
#endif    
};
3.
实现：onPowerOnConfirm
#ifdef ALARM_ASK_PWRON
mmi_ret VappAlarmIndApp::onPowerOnConfirm(mmi_event_struct *evt)
{ 
    srv_reminder_pwrreset_evt_struct *pwr_evt;
    pwr_evt = (srv_reminder_pwrreset_evt_struct *)evt;
    
    if (!pwr_evt->pwr_confirm)
    {
        //if (mmi_reminder_can_pwroff())
        if(VappAlarmApp::needPwrOff())
        {
            srv_reminder_util_send_pwroff();
        }
    }
    else
    {
        MMI_BOOL isAskPwron = MMI_FALSE;
        srv_bootup_mode_enum mode = srv_bootup_get_booting_mode();
        switch(mode)
        {
            case SRV_BOOTUP_MODE_USB:
            case SRV_BOOTUP_MODE_CHARGE:
            case SRV_BOOTUP_MODE_PRECHARGE:
            {
                //if (!mmi_gpio_is_charger_connected())
                if (!srv_charbat_is_charging())
                {
                    isAskPwron = MMI_TRUE;
                }
                break;
            }
            
            case SRV_BOOTUP_MODE_ALARM:
                isAskPwron = MMI_TRUE;
                break;
                
            default:
                break;
        }    
        
        if (isAskPwron)
        {
            //mmi_reminder_entry_pwron_confirm();
            VappAlarmParam *param;
            VFX_SYS_ALLOC_MEM(param, sizeof(VappAlarmParam));    
            param->launch_id = VappAlarmApp::ID_LAUNCH_ALARM_PWRON_CONFIRM;
            mmi_frm_nmgr_notify_by_app(
                    MMI_SCENARIO_ID_REMINDER_ALARM, 
                    MMI_EVENT_REMINDER_ALARM,
                    VappAlarmIndApp::onNmgrNotify,
                    param);     
        }
    }    
    return MMI_RET_OK;
}
#endif
4.
创建：VappAlarmPwrConfirmScr
void VappAlarmIndApp::onRun(void * args, VfxU32 argSize)
{
    VfxApp::onRun(args, argSize);
    VappAlarmParam *param = (VappAlarmParam *)args;
    VFX_ASSERT(param != NULL && argSize == sizeof(VappAlarmParam));
    VfxAppScr *scr = NULL;
#ifdef ALARM_ASK_PWRON    
    if(param->launch_id == VappAlarmApp::ID_LAUNCH_ALARM_PWRON_CONFIRM)
    {
        VFX_OBJ_CREATE(scr, 
                        VappAlarmPwrConfirmScr, 
                        this);
    }
    else
#endif
    
    if (vapp_screen_lock_is_exist())
    {
        VFX_OBJ_CREATE_EX(scr, 
                        VappAlarmCardScr, 
                        this, 
                        (param->expiry_index));
    }
    else
    {
        VFX_OBJ_CREATE_EX(scr, 
                    VappAlarmIndicationScr, 
                    this, 
                    (param->pwr_off, param->expiry_index));
    }
    if (scr != NULL)
    {
        scr->show();
    }
}
5.
定义class：
#ifdef ALARM_ASK_PWRON
#include "vcp_confirm_popup.h"
class VappAlarmPwrConfirmScr : public VfxAppScr
{
    VFX_DECLARE_CLASS(VappAlarmPwrConfirmScr);
// Override
public:
    VappAlarmPwrConfirmScr();
    ~VappAlarmPwrConfirmScr(){};
    
private:
    void onInit(void);
    void onEnter(VfxBool isBackward);
    void onRotate(const VfxScreenRotateParam & param);
    void onPopupClick(VfxObject *obj, VfxId id);
    VfxScrRotateTypeEnum onQueryRotate(const VfxScreenRotateParam ?m);
private:
    VfxWeakPtr m_popup;
};
#endif
6.
实现 class：
/***************************************************************************** 
 * Class VappAlarmPwrConfirmScr
 *****************************************************************************/
VFX_IMPLEMENT_CLASS("VappAlarmPwrConfirmScr", VappAlarmPwrConfirmScr, VfxAppScr);
VappAlarmPwrConfirmScr::VappAlarmPwrConfirmScr():
    m_popup(NULL)
{
    setIsSmallScreen();
}
void VappAlarmPwrConfirmScr::onInit(void)
{
    VfxAppScr::onInit();
    setBgColor(VFX_COLOR_TRANSPARENT);
    // display first page
    VcpConfirmPopup *pop;
    VFX_OBJ_CREATE(pop, VcpConfirmPopup, this);
    
    pop->setInfoType(VCP_POPUP_TYPE_QUESTION);
    pop->setText(VFX_WSTR_RES(ALARMS_POWER_ON)); 
    pop->setButtonSet(VCP_CONFIRM_BUTTON_SET_YES_NO);
    
    pop->setAutoDestory(VFX_TRUE);
    pop->m_signalButtonClicked.connect(this, &VappAlarmPwrConfirmScr::onPopupClick);
    m_popup = pop;
}


void VappAlarmPwrConfirmScr::onEnter(VfxBool isBackward)
{
    VfxAppScr::onEnter(isBackward);
    VcpConfirmPopup *pop = (VcpConfirmPopup *)m_popup.get();
    if (pop != NULL)
    {
        pop->show(VFX_TRUE);
    }
    else
    {
      exit();
    }
}
void VappAlarmPwrConfirmScr::onRotate(const VfxScreenRotateParam & param)
{
    VfxAppScr::onRotate(param);
}
void VappAlarmPwrConfirmScr::onPopupClick(VfxObject *obj, VfxId id)
{
    srv_reminder_notify_finish(MMI_FALSE);
    switch(id)
    {
        case VCP_CONFIRM_POPUP_BUTTON_YES:
            /*power on*/            
            srv_reminder_util_send_pwron();
            break;            
        case VCP_CONFIRM_POPUP_BUTTON_NO:            
        default:
            srv_reminder_util_send_pwroff();
            break;
    }
    
    exit();
}
VfxScrRotateTypeEnum VappAlarmPwrConfirmScr::onQueryRotate(const VfxScreenRotateParam ?m)
{
    VfxRenderer *render = VFX_OBJ_GET_INSTANCE(VfxRenderer);
    return render->getPreScreenRotateType();
}


7.
增加 ID_LAUNCH_ALARM_PWRON_CONFIRM 定义
class VappAlarmApp : public VfxApp
{
    VFX_DECLARE_CLASS(VappAlarmApp);
......
    enum
    {
        ID_LAUNCH_ALARM,
        ID_LAUNCH_ALARM_IND,
    #ifdef ALARM_ASK_PWRON
        ID_LAUNCH_ALARM_PWRON_CONFIRM,
    #endif
        ID_LAUNCH_TOTAL
    };
    
8.
确认srv_reminder_notify_finish 是否与下面相同，如果不同，请改为下面验证；
void srv_reminder_notify_finish(MMI_BOOL pwr_confirm)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                       */
    /*----------------------------------------------------------------*/
    srv_reminder_type prev;
    MMI_BOOL ret;
    
    /*----------------------------------------------------------------*/
    /* Code Body                                                           */
    /*----------------------------------------------------------------*/
    SRV_RMDR_LOG0(SRV_RMDR_NOTIFY_FINISH);
    prev = g_srv_remdr_cntx.active_type;
    g_srv_remdr_cntx.active_type = SRV_REMINDER_TYPE_TOTAL;
        
    /* Schedule next reminder */
    ret = srv_reminder_do_schedule(MMI_FALSE);
    /*
     * if no recent reminder, we should ask UI for power confirm
     */
    if (!ret && prev != SRV_REMINDER_TYPE_PWR_RESET 
                && prev != SRV_REMINDER_TYPE_POWER_ON_CONFIRM 
                && prev != SRV_REMINDER_TYPE_TOTAL)
    {
        /* for non-normal power-on mode, Ask reminder app to poweroff the phone. */
        if(srv_bootup_get_booting_mode() != SRV_BOOTUP_MODE_NORMAL)
    {
            srv_reminder_pwrreset_evt_struct evt;
            MMI_FRM_INIT_EVENT(&evt, EVT_ID_SRV_REMINDER_PWRRESET_REQ);
            evt.pwr_confirm = pwr_confirm;
                g_srv_remdr_cntx.active_type = SRV_REMINDER_TYPE_POWER_ON_CONFIRM;
            MMI_FRM_CB_EMIT_POST_EVENT(&evt);
        }
    }
}


四，确认相关代码
如果 SRV_REMINDER_TYPE_POWER_ON_CONFIRM 这个枚举没有定义，请参考下面的代码，看是否有；
如果没有，修改验证；
Patch： MAUI_02936663
1，
修改：
                if ((uem_get_power_on_mode() == POWER_ON_USB) && (srv_reminder_is_expiring() == MMI_FALSE))
为：
                if ((uem_get_power_on_mode() == POWER_ON_USB) && !srv_reminder_is_reminder_active())
具体如下：
void srv_charbat_status_ind_hdlr(void *info)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    MYQUEUE Message;
    srv_charbat_evt_notify_struct evt = {0};
    mmi_eq_battery_status_ind_struct *p = (mmi_eq_battery_status_ind_struct*) info;
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    srv_charbat_send_ack(p->battery_status);
    evt.status = p->battery_status;
    evt.battery_level = p->battery_voltage;
    
    switch (p->battery_status)
    {
        case PMIC_USB_CHARGER_IN: 
        case PMIC_CHARGER_IN:
        {
            if (PMIC_CHARGER_IN == p->battery_status) /* pwronUsb, when receive charger_in, will shutdown */
            {
                MMI_TRACE(SRV_CHARBAT_TRC, TRC_SRV_CHARBAT_EXT, 1, uem_get_power_on_mode());
                if ((uem_get_power_on_mode() == POWER_ON_USB) && !srv_reminder_is_reminder_active()) /
                {
                    mmi_frm_send_ilm(MOD_L4C, MSG_ID_MMI_EQ_POWER_OFF_REQ, NULL, NULL);
                    return;
                }
            }


2，
在 ReminderSrvGprot.h 中增加两个函数的定义：
/*****************************************************************************
 * FUNCTION
 *  srv_reminder_is_in_power_on_confirm
 * DESCRIPTION
 *  Phone is in power on confirm stage
 * PARAMETERS
 *    void 
 * RETURNS
 *  MMI_TRUE    -> the phone is in power on confirm stage
 *    MMI_FALSE -> the phone is NOT in power on confirm stage
 *****************************************************************************/
extern MMI_BOOL srv_reminder_is_in_power_on_confirm(void);
/*****************************************************************************
 * FUNCTION
 *  srv_reminder_is_reminder_active
 * DESCRIPTION
 *  Phone is in reminder active (check if is reminder expiring and in confirm stage)
 * PARAMETERS
 *    void 
 * RETURNS
 *  MMI_TRUE    -> there is reminder active
 *    MMI_FALSE -> there is no reminder active
 *****************************************************************************/
extern MMI_BOOL srv_reminder_is_reminder_active(void);


3，
在 ReminderSrv.c 中修改为如下状态：
MMI_BOOL srv_reminder_is_expiring(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                      */
    /*----------------------------------------------------------------*/
     MMI_BOOL ret;
     
    /*----------------------------------------------------------------*/
    /* Code Body                                                         */
    /*----------------------------------------------------------------*/
    ret = (g_srv_remdr_cntx.active_type != SRV_REMINDER_TYPE_TOTAL
           && g_srv_remdr_cntx.active_type != SRV_REMINDER_TYPE_POWER_ON_CONFIRM);
    
    SRV_RMDR_LOG2(SRV_RMDR_IS_EXPIRYING, ret, g_srv_remdr_cntx.active_type);
    
    return ret;
}
  
/*****************************************************************************
 * Please refer to ReminderSrvGprot.h
 *****************************************************************************/
MMI_BOOL srv_reminder_is_in_power_on_confirm(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                      */
    /*----------------------------------------------------------------*/
     MMI_BOOL ret;
     
    /*----------------------------------------------------------------*/
    /* Code Body                                                         */
    /*----------------------------------------------------------------*/
    ret = (g_srv_remdr_cntx.active_type == SRV_REMINDER_TYPE_POWER_ON_CONFIRM);
    
    return ret;
}
MMI_BOOL srv_reminder_is_reminder_active(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                      */
    /*----------------------------------------------------------------*/
     
    /*----------------------------------------------------------------*/
    /* Code Body                                                         */
    /*----------------------------------------------------------------*/
    return (srv_reminder_is_expiring() | srv_reminder_is_in_power_on_confirm());
}


/*****************************************************************************
 * Please refer to ReminderSrvGprot.h
 *****************************************************************************/
void srv_reminder_notify_finish(MMI_BOOL pwr_confirm)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                       */
    /*----------------------------------------------------------------*/
    srv_reminder_type prev;
    MMI_BOOL ret;
    
    /*----------------------------------------------------------------*/
    /* Code Body                                                           */
    /*----------------------------------------------------------------*/
    SRV_RMDR_LOG0(SRV_RMDR_NOTIFY_FINISH);
    prev = g_srv_remdr_cntx.active_type;
    g_srv_remdr_cntx.active_type = SRV_REMINDER_TYPE_TOTAL;
        
    /* Schedule next reminder */
    ret = srv_reminder_do_schedule(MMI_FALSE);
    /*
     * if no recent reminder, we should ask UI for power confirm
     */
            if (!ret && prev != SRV_REMINDER_TYPE_PWR_RESET && prev != SRV_REMINDER_TYPE_POWER_ON_CONFIRM && 
        prev != SRV_REMINDER_TYPE_TOTAL)
    {
        /* for non-normal power-on mode, Ask reminder app to poweroff the phone. */
        if(srv_bootup_get_booting_mode() != SRV_BOOTUP_MODE_NORMAL)
    {
            srv_reminder_pwrreset_evt_struct evt;
            MMI_FRM_INIT_EVENT(&evt, EVT_ID_SRV_REMINDER_PWRRESET_REQ);
            evt.pwr_confirm = pwr_confirm;
                        g_srv_remdr_cntx.active_type = SRV_REMINDER_TYPE_POWER_ON_CONFIRM;
            MMI_FRM_CB_EMIT_POST_EVENT(&evt);
        }
    }
}


4,
增加定义： SRV_REMINDER_TYPE_POWER_ON_CONFIRM, 
typedef enum
{
    SRV_REMINDER_TYPE_SPON,             /* 0 */
    SRV_REMINDER_TYPE_THEME,            /* 1 */
    SRV_REMINDER_TYPE_TASK,             /* 2 */
    SRV_REMINDER_TYPE_CAL,              /* 3 */
    SRV_REMINDER_TYPE_ALM,              /* 4 */
    SRV_REMINDER_TYPE_AZAAN,            /* 5 */
    SRV_REMINDER_TYPE_FMSR,             /* 6 */
    SRV_REMINDER_TYPE_FMRDO,            /* 7 FM alarm */
    SRV_REMINDER_TYPE_SPOF,             /* 8 schedule power off alarm */
    SRV_REMINDER_TYPE_FACTORY,          /* 9 factory alarm */
    SRV_REMINDER_TYPE_PWR_RESET,        /* 10 resets alarm */
    SRV_REMINDER_TYPE_SYNCML,           /* 11 1 alarm for syncml */
    SRV_REMINDER_TYPE_LANGLN,           /* 12 language alarm */
    SRV_REMINDER_TYPE_DTV,              /* 13 */
    
    /* Add reminder type before this line */
    SRV_REMINDER_TYPE_CUSTOM,           /* 13 */
    SRV_REMINDER_TYPE_POWER_ON_CONFIRM, /* 14 For power on confirm after alarm power on */ ///
    SRV_REMINDER_TYPE_TOTAL             /* 15 */
}srv_reminder_type;
5，
将                !srv_reminder_is_expiring())
改为：                !srv_reminder_is_reminder_active())
具体如下：
void srv_usb_handle_plug_in(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    srv_usb_status_enum usb_state = srv_usb_get_status();
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    /* USB split revise*/
    MMI_TRACE(MMI_COMMON_TRC_G8_DEV, TRC_MMI_USB_DETECT_SCR_PLUGIN, usb_state);
    SRVUSB_SET_FLAG(SRVUSB_MASK_IS_CONNECT);
    /* It is before system bootup, wait*/
    if (( !srv_bootup_is_launched() &&
         srv_bootup_get_booting_mode() == SRV_BOOTUP_MODE_NORMAL) ||
         srv_bootup_get_booting_mode() == SRV_BOOTUP_MODE_INVALID)
    {
        srv_usb_set_before_power_on_flag(MMI_TRUE);
        srv_usb_set_status(SRV_USBSTATUS_PLUGIN);
        srv_usb_pending_detection_hdlr();
        return;
    }
    switch (usb_state)
    {
        case SRV_USBSTATUS_UNKNOW:
            srv_usb_set_before_power_on_flag(MMI_TRUE);
            srv_usb_set_status(SRV_USBSTATUS_PLUGIN);
            srv_usb_pending_detection_hdlr();
            break;
            
        case SRV_USBSTATUS_PLUGOUT:
        {
            if ((srv_bootup_get_booting_mode() == SRV_BOOTUP_MODE_PRECHARGE ||
                srv_bootup_get_booting_mode() == SRV_BOOTUP_MODE_CHARGE) &&
                !srv_reminder_is_reminder_active())
            {
                srv_usb_send_msg_to_hw(MSG_ID_MMI_EQ_POWER_OFF_REQ, (void*)NULL, (void*)NULL);
                break;
            }