textphonecontrol.c

MTK手机平台的MMI部分的源代码

    result = rsp->result;
#endif /* __CTM_DEBUG */ 

    PRINT_INFORMATION(("\n CTM CONNECT RSP\n"));

    if (ctm_p->state == MMI_CTM_STATE_CONNECTING)
    {
        if (result == TRUE)
        {
            /* connect OK */
            mmi_ctm_set_state(MMI_CTM_STATE_CONNECTED);

            mmi_ctm_reset_buffer();

            /* enter chat screen */
            if (GetExitScrnID() == SCR_CTM_CONNECTING ||
            	GetExitScrnID() == SCR_CM_ACTIVECALLSCREEN)
            {
                entry_ctm_talking();
                DeleteScreenIfPresent(SCR_CM_ACTIVECALLSCREEN);
            }
        }
        else
        {
            /* connect fail */
            mmi_ctm_set_state(MMI_CTM_STATE_OPENED);
            DisplayPopup((PU8) GetString(STR_GLOBAL_UNFINISHED), IMG_GLOBAL_ERROR, 0, 2000, ERROR_TONE);
        }
    }
#ifdef __CTM_DEBUG
    StartTimer(CM_NOTIFYDURATION_TIMER, 2000, (FuncPtr) mmi_ctm_recv_text_ind_hdlr);
#endif 
    DeleteScreenIfPresent(SCR_CTM_CONNECTING);
}


/*****************************************************************************
 * FUNCTION
 *  mmi_ctm_connect_ind_hdlr
 * DESCRIPTION
 *  
 * PARAMETERS
 *  info        [?]     
 * RETURNS
 *  void
 *****************************************************************************/
void mmi_ctm_connect_ind_hdlr(void *info)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (ctm_p->state == MMI_CTM_STATE_OPENED || ctm_p->state == MMI_CTM_STATE_CONNECTING)
    {
        mmi_ctm_set_state(MMI_CTM_STATE_CONNECTED);
        mmi_ctm_reset_buffer();
    }

    /* enter chat screen */
    if (GetExitScrnID() == SCR_CM_ACTIVECALLSCREEN)
    {
        entry_ctm_talking();
        DeleteScreenIfPresent(SCR_CM_ACTIVECALLSCREEN);
    }
}


/*****************************************************************************
 * FUNCTION
 *  mmi_ctm_send_text_rsp_hdlr
 * DESCRIPTION
 *  
 * PARAMETERS
 *  info        [?]     
 * RETURNS
 *  void
 *****************************************************************************/
void mmi_ctm_send_text_rsp_hdlr(void *info)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    pBOOL result = TRUE;
    U16 finished_len;

#ifndef __CTM_DEBUG
    mmi_ctm_send_text_rsp_struct *rsp;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    rsp = (mmi_ctm_send_text_rsp_struct*) info;
    result = rsp->result;
#endif /* __CTM_DEBUG */ 

    PRINT_INFORMATION(("\n CTM SEND TEXT RSP\n"));

    finished_len = ctm_p->sent_len;
    ctm_p->sent_len = 0;

    if (result == TRUE)
    {
        if (MAX_CTM_DATA_COUNT - ctm_p->local_len > finished_len)
        {
            ctm_p->local_len += finished_len;
            pfnUnicodeStrncat((PS8) ctm_p->local_buffer, (PS8) ctm_p->pending_buffer, finished_len);
        }
        else
        {
            memset(ctm_p->local_buffer, 0, MAX_CTM_DATA_BUFFER_LEN);
            ctm_p->local_len = finished_len;
            pfnUnicodeStrncpy((PS8) ctm_p->local_buffer, (PS8) ctm_p->pending_buffer, finished_len);
        }

        ctm_p->pending_len -= finished_len;

        if (ctm_p->pending_len > 0)
        {
            pfnUnicodeStrcpy((PS8) ctm_p->pending_buffer, (PS8) & ctm_p->pending_buffer[finished_len << 1]);
        }
        else
        {
            memset(ctm_p->pending_buffer, 0, MAX_CTM_EDITOR_BUFFER_LEN);
        }

        if (finished_len > 0)
        {
            UpdateCategory430LSK(STR_GLOBAL_EDIT, 0);
        }

        if (GetExitScrnID() == SCR_CTM_TALKING)
        {
            if (ctm_p->pending_len == 0)
            {
                ConfigureCategory430SendingBox(FALSE, 0);
            }
            else
            {
                ConfigureCategory430SendingBox(TRUE, 0);
            }
        }
    }

    if (ctm_p->pending_len > 0)
    {
        mmi_ctm_send_text_req((PS8) ctm_p->pending_buffer, ctm_p->pending_len);
    }

}


/*****************************************************************************
 * FUNCTION
 *  mmi_ctm_recv_text_ind_hdlr
 * DESCRIPTION
 *  
 * PARAMETERS
 *  info        [?]     
 * RETURNS
 *  void
 *****************************************************************************/
void mmi_ctm_recv_text_ind_hdlr(void *info)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    U16 space, len;
    PU16 text;

#ifdef __CTM_DEBUG
    U16 temp[] = L"abc12345def\n";

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    len = 12;
    text = temp;
#else /* __CTM_DEBUG */ 
    mmi_ctm_recv_text_ind_struct *ind;

    ind = (mmi_ctm_recv_text_ind_struct*) info;
    len = ind->num_of_char;
    text = ind->text;
#endif /* __CTM_DEBUG */ 

    PRINT_INFORMATION(("\n CTM RECV TEXT IND\n"));

    len = mmi_skip_unicode_char(text, len, 0x0008);
    space = MAX_CTM_DATA_COUNT - ctm_p->remote_len;
    if (space > len)
    {
        ctm_p->remote_len += len;
        pfnUnicodeStrcat((PS8) ctm_p->remote_buffer, (PS8) text);
    }
    else
    {
        ctm_p->remote_len = len;
        pfnUnicodeStrcpy((PS8) ctm_p->remote_buffer, (PS8) text);
    }
    if (GetExitScrnID() == SCR_CTM_TALKING)
    {
        UpdateCategory430LogBox(TRUE, FALSE);
    }

#ifdef __CTM_DEBUG
    StartTimer(CM_AUTOANSWER_NOTIFYDURATION_TIMER, 2000, (FuncPtr) mmi_ctm_recv_text_ind_hdlr);
#endif 
}


/*****************************************************************************
 * FUNCTION
 *  mmi_ctm_tty_plug_ind_hdlr
 * DESCRIPTION
 *  
 * PARAMETERS
 *  info        [?]     
 * RETURNS
 *  void
 *****************************************************************************/
void mmi_ctm_tty_plug_ind_hdlr(void *info)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    mmi_ctm_tty_plug_ind_struct *ind;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    ind = (mmi_ctm_tty_plug_ind_struct*) info;

    /* ctm_p->tty_status = ind->is_plug_in; */

    mmi_ctm_switch_tty_status(ind->is_plug_in);
}


/*****************************************************************************
 * FUNCTION
 *  mmi_ctm_switch_tty_status
 * DESCRIPTION
 *  
 * PARAMETERS
 *  is_present      [IN]        
 *  void(?)         [IN]        *
 * RETURNS
 *  void
 *****************************************************************************/
void mmi_ctm_switch_tty_status(pBOOL is_present)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (is_present)
    {
        /* plug in */
        if (mmi_ctm_get_mode())
        {
            /* CTM on, take as TTY */
            ctm_p->tty_status = TRUE;
            if ((ctm_p->state != MMI_CTM_STATE_IDLE &&
                 ctm_p->mode_activated == CTM_DIRECT_MODE) ||
                (ctm_p->state == MMI_CTM_STATE_IDLE && GetTotalActiveCallCount() + GetTotalHoldCallCount() >= 1))
            {
                S8 mode = 0xff;

                /* plug in, open again */
                if (ctm_p->state != MMI_CTM_STATE_IDLE)
                {
                    mmi_ctm_set_state(MMI_CTM_STATE_CLOSING);
                    mmi_ctm_send_close_req();
                }
                switch (ctm_p->mode_setting)
                {
                    case MMI_CTM_SETTING_HCO:
                        mode = CTM_HCO_MODE;
                        break;
                    case MMI_CTM_SETTING_VCO:
                        mode = CTM_VCO_MODE;
                        break;
                    case MMI_CTM_SETTING_BAUDOT:
                        mode = CTM_BAUDOT_MODE;
                        break;
                    default:
                    	/* CTM ON, earphone in, direct mode => keep open as direct mode, take it as earphone */
                		mode = CTM_DIRECT_MODE;
                        break;
                }
                if (mode != 0xff)
                {
                    mmi_ctm_set_state(MMI_CTM_STATE_OPENING);
                    mmi_ctm_send_open_req(mode);
                }
            }
        }
        else
        {
            /* CTM off, take as headset */
            ctm_p->tty_status = FALSE;
        }
    }
    else
    {
        /* plug out */
        ctm_p->tty_status = FALSE;
        if (mmi_ctm_get_mode())
        {
            /* CTM on, TTY to direct */
            if (ctm_p->state != MMI_CTM_STATE_IDLE)
            {
                mmi_ctm_set_state(MMI_CTM_STATE_CLOSING);
                mmi_ctm_send_close_req();
            }

            if (((ctm_p->mode_setting == MMI_CTM_SETTING_AUTO_DIRECT ||
                  ctm_p->mode_setting == MMI_CTM_SETTING_MANUAL_DIRECT) &&
                 (ctm_p->mode_activated != CTM_DIRECT_MODE || 
                  ctm_p->state == MMI_CTM_STATE_CLOSING)) ||
                (ctm_p->state == MMI_CTM_STATE_IDLE && GetTotalActiveCallCount() + GetTotalHoldCallCount() >= 1))
            {
                /* plug out, open again */
                mmi_ctm_set_state(MMI_CTM_STATE_OPENING);
                mmi_ctm_send_open_req(CTM_DIRECT_MODE);
            }
        }
        else
        {
            /* CTM off, do nothing */
        }
    }
}


/*****************************************************************************
 * FUNCTION
 *  mmi_ctm_send_open_req
 * DESCRIPTION
 *  
 * PARAMETERS
 *  mode        [IN]        
 *  void(?)     [IN]        *
 * RETURNS
 *  void
 *****************************************************************************/
void mmi_ctm_send_open_req(U8 mode)
{
#ifndef __CTM_DEBUG
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    MYQUEUE Message;
    mmi_ctm_open_req_struct *param;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    /* ClearInputEventHandler(MMI_DEVICE_ALL); */

    Message.oslSrcId = MOD_MMI;
    Message.oslDestId = MOD_L4C;
    Message.oslMsgId = MSG_ID_MMI_CTM_OPEN_REQ;

    param = (mmi_ctm_open_req_struct*) OslConstructDataPtr(sizeof(mmi_ctm_open_req_struct));

    param->ctm_interface = mode;

    Message.oslDataPtr = (oslParaType*) param;
    Message.oslPeerBuffPtr = NULL;

    SetProtocolEventHandler(mmi_ctm_open_rsp_hdlr, MSG_ID_MMI_CTM_OPEN_RSP);
    OslMsgSendExtQueue(&Message);
#else /* __CTM_DEBUG */ 
    StartTimer(CM_NOTIFYDURATION_TIMER, 2000, (FuncPtr) mmi_ctm_open_rsp_hdlr);
#endif /* __CTM_DEBUG */ 
    PRINT_INFORMATION(("\n CTM OPEN REQ\n"));
}


/*****************************************************************************
 * FUNCTION
 *  mmi_ctm_send_close_req
 * DESCRIPTION
 *  
 * PARAMETERS
 *  void
 *  void(?)     [IN]        *
 * RETURNS
 *  void
 *****************************************************************************/
void mmi_ctm_send_close_req(void)