capiwta.c

是一个手机功能的模拟程序

    var.Param2 = wtaiEventCallAlerting(callHandle);
    var.Param1 = wip_byte2wchar("wtaev-cc/cc");

    XMK_SEND_ENV( ENV,
                  WTAEvent,
                  xDefaultPrioSignal,
                  sizeof( yPDef_WTAEvent ),
                  &var,
                  GLOBALPID(XPTID_WTA_IF,0));
}

EXPORT_C VOID    WTAIc_DTMFSent (INT16 callHandle, const WCHAR *dtmf)
{
	XMK_SEND_TMP_VARS
    yPDef_WTAEvent var;

#ifdef LOG_EXTERNAL
    {
        const WCHAR *_dtmf = dtmf;
        if (!_dtmf)
        {
            _dtmf = cwzNULL;
        }
        CLNTa_log(0, 0, "WTAIc_DTMFSent\nINT16 \t callHandle \t %i\nconst WCHAR * \t dtmf \t %S\n", (int)callHandle, _dtmf);
    }
#endif

    var.Param2 = wtaiEventDTMFSent(callHandle, dtmf);
    var.Param1 = wip_byte2wchar("wtaev-cc/dtmf");

    XMK_SEND_ENV( ENV,
                  WTAEvent,
                  xDefaultPrioSignal,
                  sizeof( yPDef_WTAEvent ),
                  &var,
                  GLOBALPID(XPTID_WTA_IF,0));
}

EXPORT_C VOID    WTAIc_networkStatus (INT8 inService, const WCHAR *networkName, INT8 explanation)
{
	XMK_SEND_TMP_VARS
    yPDef_WTAEvent var;

#ifdef LOG_EXTERNAL
    {
        const WCHAR *_networkName = networkName;
        if (!_networkName)
        {
            _networkName = cwzNULL;
        }
        CLNTa_log(0, 0, "WTAIc_networkStatus\nINT8 \t inService \t %i\n, const WCHAR * \t networkName \t %S\n, INT8 \t explanation \t %i\n", (int)inService, _networkName, (int)explanation);
    }
#endif

    var.Param2 = wtaiEventNetworkStatus(inService, networkName, explanation);
    var.Param1 = wip_byte2wchar("wtaev-ms/ns");

    XMK_SEND_ENV( ENV,
                  WTAEvent,
                  xDefaultPrioSignal,
                  sizeof( yPDef_WTAEvent ),
                  &var,
                  GLOBALPID(XPTID_WTA_IF,0));
}

EXPORT_C VOID    WTAIc_incomingMessage (INT16 textId, const WCHAR *sender)
{
	XMK_SEND_TMP_VARS
    yPDef_WTAEvent var;

#ifdef LOG_EXTERNAL
    {
        const WCHAR *_sender = sender;
        if (!_sender)
        {
            _sender = cwzNULL;
        }
        CLNTa_log(0, 0, "WTAIc_incomingMessage\nINT16 \t textId \t %i\n, const WCHAR * \t sender \t %S\n", (int)textId, _sender);
    }
#endif

    var.Param2 = wtaiEventIncomingMessage(textId, sender);
    var.Param1 = wip_byte2wchar("wtaev-nt/it");

    XMK_SEND_ENV( ENV,
                  WTAEvent,
                  xDefaultPrioSignal,
                  sizeof( yPDef_WTAEvent ),
                  &var,
                  GLOBALPID(XPTID_WTA_IF,0));
}

EXPORT_C VOID    WTAIc_messageSendStatus (INT16 msgHandle, INT8 textId)
{
	XMK_SEND_TMP_VARS
    yPDef_WTAEvent var;

#ifdef LOG_EXTERNAL
    {
        CLNTa_log(0, 0, "WTAIc_messageSendStatus\nINT16 \t msgHandle \t %i\nINT8 \t textId \t %i\n", (int)msgHandle, (int)textId);
    }
#endif

    var.Param2 = wtaiEventMessageSendStatus(msgHandle, textId);
    var.Param1 = wip_byte2wchar("wtaev-nt/st");

    XMK_SEND_ENV( ENV,
                  WTAEvent,
                  xDefaultPrioSignal,
                  sizeof( yPDef_WTAEvent ),
                  &var,
                  GLOBALPID(XPTID_WTA_IF,0));
}


EXPORT_C VOID    WTAIc_callHeld (INT16 callHandle)
{
	XMK_SEND_TMP_VARS
    yPDef_WTAEvent var;

#ifdef LOG_EXTERNAL
    {
        CLNTa_log(0, 0, "WTAIc_callHeld\nINT16 \t callHandle \t %i\n", (int)callHandle);
    }
#endif

    var.Param2 = wtaiEventCallHeld(callHandle);
    var.Param1 = wip_byte2wchar("wtaev-gsm/ch");

    XMK_SEND_ENV( ENV,
                  WTAEvent,
                  xDefaultPrioSignal,
                  sizeof( yPDef_WTAEvent ),
                  &var,
                  GLOBALPID(XPTID_WTA_IF,0));
}

EXPORT_C VOID    WTAIc_callActive (INT16 callHandle)
{
	XMK_SEND_TMP_VARS
    yPDef_WTAEvent var;

#ifdef LOG_EXTERNAL
    {
        CLNTa_log(0, 0, "WTAIc_callActive\nINT16 \t callHandle \t %i\n", (int)callHandle);
    }
#endif

    var.Param2 = wtaiEventCallActive(callHandle);
    var.Param1 = wip_byte2wchar("wtaev-gsm/ca");

    XMK_SEND_ENV( ENV,
                  WTAEvent,
                  xDefaultPrioSignal,
                  sizeof( yPDef_WTAEvent ),
                  &var,
                  GLOBALPID(XPTID_WTA_IF,0));
}

EXPORT_C VOID    WTAIc_USSDReceived (const WCHAR *text, const WCHAR *dataCodingScheme, INT8 type, const WCHAR *transactionId)
{
	XMK_SEND_TMP_VARS
    yPDef_WTAEvent var;

#ifdef LOG_EXTERNAL
    {
        char    szFormat[256];
        size_t  strlength, end = 0;
        const char  *csz;
        const WCHAR *_text = text;
        const WCHAR *_dataCodingScheme = dataCodingScheme;
        const WCHAR *_transactionId = transactionId;

        if (!_text)
        {
            _text = cwzNULL;
        }
        if (!_dataCodingScheme)
        {
            _dataCodingScheme = cwzNULL;
        }
        strlength = strlen(csz = "WTAIc_USSDReceived\nconst WCHAR * \t text \t %S\n, const WCHAR * \t dataCodingScheme \t %S\n, INT8 \t type \t %i   (");
        strncpy(&szFormat[end], csz, strlength);
        end += strlength;
        switch (type)
        {
            case WTA_USSD_RECEIVED_RESULT:  /*  0 */
                csz = "WTA_USSD_RECEIVED_RESULT";
                break;
            case WTA_USSD_RECEIVED_REQUEST:      /*  1 */
                csz = "WTA_USSD_RECEIVED_REQUEST";
                break;
            case WTA_USSD_RECEIVED_NOTIFY:      /*  2 */
                csz = "WTA_USSD_RECEIVED_NOTIFY";
                break;
            case WTA_USSD_RECEIVED_ERROR:  /*  3 */
                csz = "WTA_USSD_RECEIVED_ERROR";
/*              what is this? ASPN
                pText = pDCS = cwzNULL;
*/
				break;
            default:
                csz = "Currently not a supported USSD operation.";
                break;
        }
        strlength = strlen(csz);
        strncpy(&szFormat[end], csz, strlength);
        end += strlength;
        strlength = strlen(csz = ")\n, const WCHAR * \t transactionId \t %S\n");
        strncpy(&szFormat[end], csz, strlength);
        end += strlength;
        if (!_transactionId)
        {
            _transactionId = cwzNULL;
        }

        szFormat[end] = '\0';
        CLNTa_log(0, 0, szFormat, _text, _dataCodingScheme, (int)type, _transactionId);
    }
#endif

    var.Param2 = wtaiEventUSSD_Received(text, dataCodingScheme, type, transactionId);
    var.Param1 = wip_byte2wchar("wtaev-gsm/ru");

    XMK_SEND_ENV( ENV,
                  WTAEvent,
                  xDefaultPrioSignal,
                  sizeof( yPDef_WTAEvent ),
                  &var,
                  GLOBALPID(XPTID_WTA_IF,0));
}




/* Services */

EXPORT_C VOID    WTAc_terminateService (VOID)
{
	XMK_SEND_TMP_VARS

#ifdef LOG_EXTERNAL
    {
        CLNTa_log(0, 0, "WTAc_terminateService\nVOID");
    }
#endif

    XMK_SEND_ENV( ENV,
                  TerminateWTAService,
                  xDefaultPrioSignal,
                  0,
                  NULL,
                  GLOBALPID(XPTID_WTA_IF,0));
}

EXPORT_C VOID    WTAc_confirmInstallation (INT8 installId, BOOL install)
{
	XMK_SEND_TMP_VARS
    yPDef_WTAcConfirmInstallation var;

#ifdef LOG_EXTERNAL
    {
        CLNTa_log(0, 0, "WTAc_confirmInstallation\nINT8 \t installId \t %i\n, BOOL \t install \t %u\n", (int)installId, (int)install);
    }
#endif

    var.Param1 = installId;
    var.Param2 = install;

    XMK_SEND_ENV( ENV,
                  WTAcConfirmInstallation,
                  xDefaultPrioSignal,
                  sizeof( yPDef_WTAcConfirmInstallation ),
                  &var,
                  GLOBALPID(XPTID_RepH_ME,0));
}

EXPORT_C VOID    WTAc_retryGetInstallationResult (INT8 installId, BOOL retry)
{
	XMK_SEND_TMP_VARS
    yPDef_WTAcRetryGetInstallationResult var;

#ifdef LOG_EXTERNAL
    {
        CLNTa_log(0, 0, "WTAc_retryGetInstallationResult\nINT8 \t installId \t %i\n, BOOL \t retry \t %u\n", (int)installId, (int)retry);
    }
#endif

    var.Param1 = installId;
    var.Param2 = retry;

    XMK_SEND_ENV( ENV,
                  WTAcRetryGetInstallationResult,
                  xDefaultPrioSignal,
                  sizeof( yPDef_WTAcRetryGetInstallationResult ),
                  &var,
                  GLOBALPID(XPTID_RepH_ME,0));
}

EXPORT_C VOID    WTAc_showInstallationResult (INT8 installId, BOOL show)
{
	XMK_SEND_TMP_VARS
    yPDef_WTAcShowInstallationResult var;

#ifdef LOG_EXTERNAL
    {
        CLNTa_log(0, 0, "WTAc_showInstallationResult\nINT8 \t installId \t %i\n, BOOL \t show \t %u\n", (int)installId, (int)show);
    }
#endif

    var.Param1 = installId;
    var.Param2 = show;

    XMK_SEND_ENV( ENV,
                  WTAcShowInstallationResult,
                  xDefaultPrioSignal,
                  sizeof( yPDef_WTAcShowInstallationResult ),
                  &var,
                  GLOBALPID(XPTID_RepH_ME,0));
}

EXPORT_C VOID    WTAc_abortInstallation (INT8 installId)
{
	XMK_SEND_TMP_VARS
    yPDef_WTAcAbortInstallation var;

#ifdef LOG_EXTERNAL
    {
        CLNTa_log(0, 0, "WTAc_abortInstallation\nINT8 \t installId \t %i\n", (int)installId);
    }
#endif

    var.Param1 = installId;

    XMK_SEND_ENV( ENV,
                  WTAcAbortInstallation,
                  xDefaultPrioSignal,
                  sizeof( yPDef_WTAcAbortInstallation ),
                  &var,
                  GLOBALPID(XPTID_RepH_ME,0));
}

EXPORT_C VOID    WTAc_getServices (VOID)
{
	XMK_SEND_TMP_VARS

#ifdef LOG_EXTERNAL
    {
        CLNTa_log(0, 0, "WTAc_getServices\nVOID\n");
    }
#endif

    XMK_SEND_ENV( ENV,
                  WTAcGetServices,
                  xDefaultPrioSignal,
                  0,
                  NULL,
                  GLOBALPID(XPTID_RepH_ME,0));
}


EXPORT_C VOID    WTAc_serviceAccessible (const WCHAR *wtaChannelId, BOOL status)
{
	XMK_SEND_TMP_VARS
    yPDef_WTAcServiceAccessible var;
    WCHAR   *wz;

#ifdef LOG_EXTERNAL
    {
        const WCHAR *_wtaChannelId = wtaChannelId;
        if (!_wtaChannelId)
        {
            _wtaChannelId = cwzNULL;
        }
        CLNTa_log(0, 0, "WTAc_serviceAccessible\nconst WCHAR * \t wtaChannelId \t %S\nBOOL \t status \t %u\n", _wtaChannelId, (int)status);
    }
#endif

    wz = NULL;
    if (wtaChannelId)
    {
        size_t  len;
        /*  Add one character for the terminating zero. */
        len = (w_strlen(wtaChannelId) + 1) * sizeof(WCHAR);
        wz = (WCHAR *)OSConnectorAlloc(len);
        if (!wz)
            return;
        memcpy(wz, wtaChannelId, len);
    }

    var.Param1 = wz;
    var.Param2 = status;

    XMK_SEND_ENV( ENV,
                  WTAcServiceAccessible,
                  xDefaultPrioSignal,
                  sizeof( yPDef_WTAcServiceAccessible ),
                  &var,
                  GLOBALPID(XPTID_RepH_ME,0));
}

EXPORT_C VOID    WTAc_deleteService (const WCHAR *wtaChannelId)
{
	XMK_SEND_TMP_VARS
    yPDef_WTAcDeleteService var;
    WCHAR   *wz;

#ifdef LOG_EXTERNAL
    {
        const WCHAR *_wtaChannelId = wtaChannelId;
        if (!_wtaChannelId)
        {
            _wtaChannelId = cwzNULL;
        }
        CLNTa_log(0, 0, "WTAc_deleteService\nconst WCHAR * \t wtaChannelId \t %S\n", _wtaChannelId);
    }
#endif

    wz = NULL;
    if (wtaChannelId)
    {
        size_t  len;
        /*  Add one character for the terminating zero. */
        len = (w_strlen(wtaChannelId) + 1) * sizeof(WCHAR);
        wz = (WCHAR *)OSConnectorAlloc(len);
        if (!wz)
            return;
        memcpy(wz, wtaChannelId, len);
    }
    var.Param1 = wz;

    XMK_SEND_ENV( ENV,
                  WTAcDeleteService,
                  xDefaultPrioSignal,
                  sizeof( yPDef_WTAcDeleteService ),
                  &var,
                  GLOBALPID(XPTID_RepH_ME,0));
}

EXPORT_C VOID    WTAc_executeService (const WCHAR *wtaChannelId)
{
	XMK_SEND_TMP_VARS
    yPDef_WTAExecuteService var;
    WCHAR   *wz;

#ifdef LOG_EXTERNAL
    {
        const WCHAR *_wtaChannelId = wtaChannelId;
        if (!_wtaChannelId)
        {
            _wtaChannelId = cwzNULL;
        }
        CLNTa_log(0, 0, "WTAc_executeService\nconst WCHAR * \t wtaChannelId \t %S\n", _wtaChannelId);
    }
#endif

    wz = NULL;
    if (wtaChannelId)
    {
        size_t  len;
        /*  Add one character for the terminating zero. */
        len = (w_strlen(wtaChannelId) + 1) * sizeof(WCHAR);
        wz = (WCHAR *)OSConnectorAlloc(len);
        if (!wz)
            return;
        memcpy(wz, wtaChannelId, len);
    }
    var.Param1 = wz;

    XMK_SEND_ENV( ENV,
                  WTAExecuteService,
                  xDefaultPrioSignal,
                  sizeof( yPDef_WTAExecuteService ),
                  &var,
                  GLOBALPID(XPTID_WTA_IF,0));
}

EXPORT_C VOID    WTAc_clearServices (VOID)
{
	XMK_SEND_TMP_VARS

#ifdef LOG_EXTERNAL
    {
        CLNTa_log(0, 0, "WTAc_clearServices\nVOID\n");
    }
#endif

    XMK_SEND_ENV( ENV,
                  WTAcClearServices,
                  xDefaultPrioSignal,
                  0,
                  NULL,
                  GLOBALPID(XPTID_RepH_ME,0));
}


#endif