cpcall.cpp

基于sipfoundy 公司开发的sipx协议API

        }
    }

    if (mListenerCnt == mMaxNumListeners)
    {
        //make more of em.
        mMaxNumListeners += 20;
        mpListeners = (TaoListenerDb **)realloc(mpListeners,sizeof(TaoListenerDb *)*mMaxNumListeners);
        for (int loop = mListenerCnt;loop < mMaxNumListeners;loop++)
            mpListeners[loop] = 0 ;
    }

    // add to listenerDb
    TaoListenerDb *pListenerDb = new TaoListenerDb();
    if (callId)
        pListenerDb->mName.append(callId);
    pListenerDb->mpListenerPtr = (int) pListener;
    pListenerDb->mRef = 1;
    pListenerDb->mId = connectId;
    pListenerDb->mIntData = pEv;
    pListeners[listenerCnt++] = pListenerDb;

    return OS_SUCCESS;
}

void CpCall::postMetaEvent(int state, int remoteIsCallee)
{
    if (mMetaEventType != PtEvent::META_EVENT_NONE && mListenerCnt > 0)
    {
        int eventId = PtEvent::META_UNKNOWN;

        switch (mMetaEventType)
        {
        case PtEvent::META_CALL_STARTING:
            if (state == METAEVENT_START)
                eventId = PtEvent::CALL_META_CALL_STARTING_STARTED;
            else if (state == METAEVENT_END)
                eventId = PtEvent::CALL_META_CALL_STARTING_ENDED;
            break;

        case PtEvent::META_CALL_PROGRESS:
            if (state == METAEVENT_START)
                eventId = PtEvent::SINGLECALL_META_PROGRESS_STARTED;
            else if (state == METAEVENT_END)
                eventId = PtEvent::SINGLECALL_META_PROGRESS_ENDED;
            break;

        case PtEvent::META_CALL_ADDITIONAL_PARTY:
            if (state == METAEVENT_START)
                eventId = PtEvent::CALL_META_ADD_PARTY_STARTED;
            else if (state == METAEVENT_END)
                eventId = PtEvent::CALL_META_ADD_PARTY_ENDED;
            break;

        case PtEvent::META_CALL_REMOVING_PARTY:
            if (state == METAEVENT_START)
                eventId = PtEvent::CALL_META_REMOVE_PARTY_STARTED;
            else if (state == METAEVENT_END)
                eventId = PtEvent::CALL_META_REMOVE_PARTY_ENDED;
            break;

        case PtEvent::META_CALL_ENDING:
            if (state == METAEVENT_START)
                eventId = PtEvent::CALL_META_CALL_ENDING_STARTED;
            else if (state == METAEVENT_END)
                eventId = PtEvent::CALL_META_CALL_ENDING_ENDED;
            break;

        case PtEvent::META_CALL_MERGING:
            if (state == METAEVENT_START)
                eventId = PtEvent::MULTICALL_META_MERGE_STARTED;
            else if (state == METAEVENT_END)
                eventId = PtEvent::MULTICALL_META_MERGE_ENDED;
            break;

        case PtEvent::META_CALL_TRANSFERRING:
            if (state == METAEVENT_START)
                eventId = PtEvent::MULTICALL_META_TRANSFER_STARTED;
            else if (state == METAEVENT_END)
                eventId = PtEvent::MULTICALL_META_TRANSFER_ENDED;
            break;

        case PtEvent::META_SNAPSHOT:
            if (state == METAEVENT_START)
                eventId = PtEvent::SINGLECALL_META_SNAPSHOT_STARTED;
            else if (state == METAEVENT_END)
                eventId = PtEvent::SINGLECALL_META_SNAPSHOT_ENDED;
            break;

        default:
        case PtEvent::META_UNKNOWN:
            osPrintf("CpCall::postMetaEvent - UNKNOWN_EVENT 0x%3x\n", mMetaEventId);
            eventId = PtEvent::META_UNKNOWN;
            break;
        }

        if (remoteIsCallee != -1)
        {
            postTaoListenerMessage(0, "", eventId, CALL_STATE, PtEvent::CAUSE_UNKNOWN, remoteIsCallee);
        }
        else
        {
            postTaoListenerMessage(0, "", eventId, CALL_STATE, PtEvent::CAUSE_UNKNOWN);
        }
    }

}

void CpCall::postTaoListenerMessage(int responseCode,
                                    UtlString responseText,
                                    int eventId,
                                    int type,
                                    int cause,
                                    int remoteIsCallee,
                                    UtlString remoteAddress,
                                    int isRemote,
                                    UtlString targetCallId)
{
    if (type == CONNECTION_STATE && !PtEvent::isStateTransitionAllowed(eventId, mLocalConnectionState))
    {
        osPrintf("Connection state change from %d to %d is illegal\n", mLocalConnectionState, eventId);
        return;
    }

    if (type == CONNECTION_STATE)
        mLocalConnectionState = eventId;
    else if (type == TERMINAL_CONNECTION_STATE)
        mLocalTermConnectionState = tcStateFromEventId(eventId);

    if (mListenerCnt > 0 && eventId != PtEvent::EVENT_INVALID)
    {
        char    buf[128];
        UtlString arg;
        UtlString callId;
        if (targetCallId == OsUtil::NULL_OS_STRING)
            getCallId(callId);
        else
            callId.append(targetCallId.data());

        getLocalAddress(buf, 127);
        arg = callId;                                                                   // arg[0]
        arg.append(TAOMESSAGE_DELIMITER);
        arg.append(buf); // call id, local address              // arg[1]
        if (remoteAddress.isNull())
        {
            arg.append(TAOMESSAGE_DELIMITER);                       // arg[2]
            arg.append("UNKNOWN");  // remote address not available yet
        }
        else
        {
            arg.append(TAOMESSAGE_DELIMITER);                       // arg[2]
            arg.append(remoteAddress);      // remote address
        }

        arg.append(TAOMESSAGE_DELIMITER);                               // arg[3]
        if (remoteIsCallee)                             // remoteiscallee?
            arg.append("1");
        else
            arg.append("0");

        sprintf(buf, "%d", cause);
        arg.append(TAOMESSAGE_DELIMITER);
        arg.append(buf);        // cause                                        // arg[4]

        int argCnt = 9;
        //              if (type == TERMINAL_CONNECTION_STATE)  // local terminal name
        //              {
        getLocalTerminalId(buf, 127);
        arg.append(TAOMESSAGE_DELIMITER);
        arg.append(buf);                                                        // arg[5]
        //                      argCnt = 7;
        //              }

        arg.append(TAOMESSAGE_DELIMITER);                               // arg[6]
        if (isRemote)                                           // isLocal
            arg.append("0");
        else
            arg.append("1");

        sprintf(buf, "%d", responseCode);                               // arg[7]
        arg += TAOMESSAGE_DELIMITER + UtlString(buf);   // SIP response code

        arg += TAOMESSAGE_DELIMITER + responseText;             // arg[8] SIP response text

        if (mMetaEventId > 0)
        {
            arg.append(TAOMESSAGE_DELIMITER);
            sprintf(buf, "%d", mMetaEventId);                       // arg[9]
            arg.append(buf);

            arg.append(TAOMESSAGE_DELIMITER);
            sprintf(buf, "%d", mMetaEventType);                     // arg[10]
            arg.append(buf);

            if(mpMetaEventCallIds)
            {
                for (int i = 0; i < mNumMetaEventCalls; i++)
                {
                    arg.append(TAOMESSAGE_DELIMITER);
                    arg.append(mpMetaEventCallIds[i]);
                }
            }

            argCnt += (mNumMetaEventCalls + 2);
        }

        TaoMessage msg(TaoMessage::EVENT,
            0,
            0,
            eventId,
            0,
            argCnt,
            arg);

        for (int i = 0; i < mListenerCnt; i++)
        {
            if (mpListeners[i] && mpListeners[i]->mpListenerPtr)
                ((OsServerTask*) (mpListeners[i]->mpListenerPtr))->postMessage((OsMsg&)msg);
        }

        UtlString eventLog;
        getStateString(eventId, &eventLog);
        UtlString causeStr;

        switch(cause)
        {
        case PtEvent::CAUSE_UNHOLD:
            causeStr.append("CAUSE_UNHOLD");
            break;
        case PtEvent::CAUSE_UNKNOWN:
            causeStr.append("CAUSE_UNKNOWN");
            break;
        case PtEvent::CAUSE_REDIRECTED:
            causeStr.append("CAUSE_REDIRECTED");
            break ;

        case PtEvent::CAUSE_NETWORK_CONGESTION:
            causeStr.append("CAUSE_NETWORK_CONGESTION");
            break;

        case PtEvent::CAUSE_NETWORK_NOT_OBTAINABLE:
            causeStr.append("CAUSE_NETWORK_NOT_OBTAINABLE");
            break;

        case PtEvent::CAUSE_DESTINATION_NOT_OBTAINABLE:
            causeStr.append("CAUSE_DESTINATION_NOT_OBTAINABLE");
            break;

        case PtEvent::CAUSE_INCOMPATIBLE_DESTINATION:
            causeStr.append("CAUSE_INCOMPATIBLE_DESTINATION");
            break;

        case PtEvent::CAUSE_NOT_ALLOWED:
            causeStr.append("CAUSE_NOT_ALLOWED");
            break;

        case PtEvent::CAUSE_NETWORK_NOT_ALLOWED:
            causeStr.append("CAUSE_NETWORK_NOT_ALLOWED");
            break;

        case PtEvent::CAUSE_BUSY:
            causeStr.append("CAUSE_BUSY");
            break ;

        case PtEvent::CAUSE_CALL_CANCELLED:
            causeStr.append("CAUSE_CALL_CANCELLED");
            break ;

        case PtEvent::CAUSE_TRANSFER:
            causeStr.append("CAUSE_TRANSFER");
            break;

        case PtEvent::CAUSE_NEW_CALL:
            causeStr.append("CAUSE_NEW_CALL");
            break;

        default:
        case PtEvent::CAUSE_NORMAL:
            causeStr.append("CAUSE_NORMAL");
            break;
        }
        mpManager->logCallState(arg.data(), eventLog.data(), causeStr.data());

        arg.remove(0);
        callId.remove(0);
        eventLog.remove(0);
        causeStr.remove(0);
    }
}

int CpCall::tcStateFromEventId(int eventId)
{
    int state = 0;

    switch(eventId)
    {
    case PtEvent::TERMINAL_CONNECTION_CREATED:
    case PtEvent::TERMINAL_CONNECTION_IDLE:
        state = PtTerminalConnection::IDLE;
        break;

    case PtEvent::TERMINAL_CONNECTION_HELD:
        state = PtTerminalConnection::HELD;
        break;

    case PtEvent::TERMINAL_CONNECTION_RINGING:
        state = PtTerminalConnection::RINGING;
        break;

    case PtEvent::TERMINAL_CONNECTION_TALKING:
        state = PtTerminalConnection::TALKING;
        break;

    case PtEvent::TERMINAL_CONNECTION_IN_USE:
        state = PtTerminalConnection::IN_USE;
        break;

    case PtEvent::TERMINAL_CONNECTION_DROPPED:
        state = PtTerminalConnection::DROPPED;
        break;

    default:
        state = PtTerminalConnection::UNKNOWN;
        break;
    }

    return state;
}

/* //////////////////////////// PRIVATE /////////////////////////////////// */

void CpCall::removeFromDtmfEventList(int ev)
{
    for (int i = 0; i < mDtmfQLen; i++)
    {
        if (mDtmfEvents[i].event == ev)
        {
            for (int j = i; j < (mDtmfQLen - 1); j++)
            {
                mDtmfEvents[j].event = mDtmfEvents[j + 1].event;
                mDtmfEvents[j].interdigitSecs = mDtmfEvents[j + 1].interdigitSecs;
                mDtmfEvents[j].timeoutSecs = mDtmfEvents[j + 1].timeoutSecs;
                mDtmfEvents[j].ignoreKeyUp = mDtmfEvents[j + 1].ignoreKeyUp;
            }
            mDtmfQLen--;
        }
    }
}

int CpCall::dtmfEventExists(int ev)
{
    int found = -1;
    for (int i = 0; i < mDtmfQLen; i++)
    {
        if (mDtmfEvents[i].event == ev)
        {
            found = i;
            break;
        }
    }
    return found;
}

/* ============================ FUNCTIONS ================================= */

OsStatus CpCall::addToCallTrackingList(UtlString &rCallTaskName)
{
    OsStatus retval = OS_FAILED;

    if (!spCallTrackingList)
        spCallTrackingList = new OsLockingList();

    UtlString *tmpTaskName = new UtlString(rCallTaskName);
    spCallTrackingList->push((void *)tmpTaskName);
    retval = OS_SUCCESS; //push doesn't have a return value

    return retval;
}



//Removes a call task from the tracking list, then deletes it.
//
OsStatus CpCall::removeFromCallTrackingList(UtlString &rCallTaskName)
{
    OsStatus retval = OS_FAILED;


    UtlString *pStrFoundTaskName;

    //get an iterator handle for safe traversal
    int iteratorHandle = spCallTrackingList->getIteratorHandle();

    pStrFoundTaskName = (UtlString *)spCallTrackingList->next(iteratorHandle);
    while (pStrFoundTaskName)
    {
        // we found a Call task name that matched.  Lets remove it
        if (*pStrFoundTaskName == rCallTaskName)
        {
            spCallTrackingList->remove(iteratorHandle);
            delete pStrFoundTaskName;
            retval = OS_SUCCESS;
        }

        pStrFoundTaskName = (UtlString *)spCallTrackingList->next(iteratorHandle);
    }

    spCallTrackingList->releaseIteratorHandle(iteratorHandle);

    return retval;
}

//returns number of call tasks being tracked
int CpCall::getCallTrackingListCount()
{
    int numCalls = 0;

    if (spCallTrackingList)
        numCalls = spCallTrackingList->getCount();

    return numCalls;
}