cpcall.cpp

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

    return(mCallIndex);
}

int CpCall::getCallState()
{
    return(mCallState);
}

void CpCall::printCall()
{
    UtlString callId;
    getCallId(callId);
    osPrintf("call[%d] id: %s state: %d%s\n", mCallIndex,
        callId.data(), getCallState(), mDropping ? ", Dropping" : "");

    osPrintf("Call message history:\n");
    for(int historyIndex = 0; historyIndex < CP_CALL_HISTORY_LENGTH; historyIndex++)
    {
        if(mMessageEventCount - historyIndex >= 0)
        {
            osPrintf("%d) %s\n", mMessageEventCount - historyIndex,
                (mCallHistory[(mMessageEventCount - historyIndex) % CP_CALL_HISTORY_LENGTH]).data());
        }
    }
    osPrintf("=====================\n");
}

void CpCall::getCallId(UtlString& callId)
{
    OsReadLock lock(mCallIdMutex);
    callId = mCallId;
}

void CpCall::setCallId(const char* callId)
{
    OsWriteLock lock(mCallIdMutex);
    mCallId.remove(0);
    if(callId) mCallId.append(callId);
}

void CpCall::enableDtmf()
{
    mDtmfEnabled = TRUE;
}

int CpCall::getLocalConnectionState(int state)
{
    int newState;

    switch(state)
    {
    case PtEvent::CONNECTION_CREATED:
    case PtEvent::CONNECTION_INITIATED:
        newState = Connection::CONNECTION_INITIATED;
        break;

    case PtEvent::CONNECTION_ALERTING:
        newState = Connection::CONNECTION_ALERTING;
        break;

    case PtEvent::CONNECTION_DISCONNECTED:
        newState = Connection::CONNECTION_DISCONNECTED;
        break;

    case PtEvent::CONNECTION_FAILED:
        newState = Connection::CONNECTION_FAILED;
        break;

    case PtEvent::CONNECTION_DIALING:
        newState = Connection::CONNECTION_DIALING;
        break;

    case PtEvent::CONNECTION_ESTABLISHED:
        newState = Connection::CONNECTION_ESTABLISHED;
        break;

    case PtEvent::CONNECTION_NETWORK_ALERTING:
        newState = Connection::CONNECTION_NETWORK_ALERTING;
        break;

    case PtEvent::CONNECTION_NETWORK_REACHED:
        newState = Connection::CONNECTION_NETWORK_REACHED;
        break;

    case PtEvent::CONNECTION_OFFERED:
        newState = Connection::CONNECTION_OFFERING;
        break;

    case PtEvent::CONNECTION_QUEUED:
        newState = Connection::CONNECTION_QUEUED;
        break;

    default:
        newState = Connection::CONNECTION_UNKNOWN;
        break;

    }

    return newState;
}

void CpCall::getStateString(int state, UtlString* stateLabel)
{
    stateLabel->remove(0);

    switch(state)
    {
    case PtEvent::CONNECTION_CREATED:
        stateLabel->append("CONNECTION_CREATED");
        break;

    case PtEvent::CONNECTION_ALERTING:
        stateLabel->append("CONNECTION_ALERTING");
        break;

    case PtEvent::CONNECTION_DISCONNECTED:
        stateLabel->append("CONNECTION_DISCONNECTED");
        break;

    case PtEvent::CONNECTION_FAILED:
        stateLabel->append("CONNECTION_FAILED");
        break;

    case PtEvent::CONNECTION_DIALING:
        stateLabel->append("CONNECTION_DIALING");
        break;

    case PtEvent::CONNECTION_ESTABLISHED:
        stateLabel->append("CONNECTION_ESTABLISHED");
        break;

    case PtEvent::CONNECTION_INITIATED:
        stateLabel->append("CONNECTION_INITIATED");
        break;

    case PtEvent::CONNECTION_NETWORK_ALERTING:
        stateLabel->append("CONNECTION_NETWORK_ALERTING");
        break;

    case PtEvent::CONNECTION_NETWORK_REACHED:
        stateLabel->append("CONNECTION_NETWORK_REACHED");
        break;

    case PtEvent::CONNECTION_OFFERED:
        stateLabel->append("CONNECTION_OFFERED");
        break;

    case PtEvent::CONNECTION_QUEUED:
        stateLabel->append("CONNECTION_QUEUED");
        break;

    case PtEvent::TERMINAL_CONNECTION_CREATED:
        stateLabel->append("TERMINAL_CONNECTION_CREATED");
        break;

    case PtEvent::TERMINAL_CONNECTION_RINGING:
        stateLabel->append("TERMINAL_CONNECTION_RINGING");
        break;

    case PtEvent::TERMINAL_CONNECTION_DROPPED:
        stateLabel->append("TERMINAL_CONNECTION_DROPPED");
        break;

    case PtEvent::TERMINAL_CONNECTION_UNKNOWN:
        stateLabel->append("TERMINAL_CONNECTION_UNKNOWN");
        break;

    case PtEvent::TERMINAL_CONNECTION_HELD:
        stateLabel->append("TERMINAL_CONNECTION_HELD");
        break;

    case PtEvent::TERMINAL_CONNECTION_IDLE:
        stateLabel->append("TERMINAL_CONNECTION_IDLE");
        break;

    case PtEvent::TERMINAL_CONNECTION_IN_USE:
        stateLabel->append("TERMINAL_CONNECTION_IN_USE");
        break;

    case PtEvent::TERMINAL_CONNECTION_TALKING:
        stateLabel->append("TERMINAL_CONNECTION_TALKING");
        break;

    case PtEvent::CALL_ACTIVE:
        stateLabel->append("CALL_ACTIVE");
        break;

    case PtEvent::CALL_INVALID:
        stateLabel->append("CALL_INVALID");
        break;

    case PtEvent::EVENT_INVALID:
        stateLabel->append("!! INVALID_STATE !!");
        break;

    case PtEvent::CALL_META_CALL_STARTING_STARTED:
        stateLabel->append("CALL_META_CALL_STARTING_STARTED");
        break;

    case PtEvent::CALL_META_CALL_STARTING_ENDED:
        stateLabel->append("CALL_META_CALL_STARTING_ENDED");
        break;

    case PtEvent::SINGLECALL_META_PROGRESS_STARTED:
        stateLabel->append("SINGLECALL_META_PROGRESS_STARTED");
        break;

    case PtEvent::SINGLECALL_META_PROGRESS_ENDED:
        stateLabel->append("SINGLECALL_META_PROGRESS_ENDED");
        break;

    case PtEvent::CALL_META_ADD_PARTY_STARTED:
        stateLabel->append("CALL_META_ADD_PARTY_STARTED");
        break;

    case PtEvent::CALL_META_ADD_PARTY_ENDED:
        stateLabel->append("CALL_META_ADD_PARTY_ENDED");
        break;

    case PtEvent::CALL_META_REMOVE_PARTY_STARTED:
        stateLabel->append("CALL_META_REMOVE_PARTY_STARTED");
        break;

    case PtEvent::CALL_META_REMOVE_PARTY_ENDED:
        stateLabel->append("CALL_META_REMOVE_PARTY_ENDED");
        break;

    case PtEvent::CALL_META_CALL_ENDING_STARTED:
        stateLabel->append("CALL_META_CALL_ENDING_STARTED");
        break;

    case PtEvent::CALL_META_CALL_ENDING_ENDED:
        stateLabel->append("CALL_META_CALL_ENDING_ENDED");
        break;

    case PtEvent::MULTICALL_META_MERGE_STARTED:
        stateLabel->append("MULTICALL_META_MERGE_STARTED");
        break;

    case PtEvent::MULTICALL_META_MERGE_ENDED:
        stateLabel->append("MULTICALL_META_MERGE_ENDED");
        break;

    case PtEvent::MULTICALL_META_TRANSFER_STARTED:
        stateLabel->append("MULTICALL_META_TRANSFER_STARTED");
        break;

    case PtEvent::MULTICALL_META_TRANSFER_ENDED:
        stateLabel->append("MULTICALL_META_TRANSFER_ENDED");
        break;

    case PtEvent::SINGLECALL_META_SNAPSHOT_STARTED:
        stateLabel->append("SINGLECALL_META_SNAPSHOT_STARTED");
        break;

    case PtEvent::SINGLECALL_META_SNAPSHOT_ENDED:
        stateLabel->append("SINGLECALL_META_SNAPSHOT_ENDED");
        break;

    default:
        stateLabel->append("STATE_UNKNOWN");
        break;

    }

}

void CpCall::setMetaEvent(int metaEventId, int metaEventType,
                          int numCalls, const char* metaEventCallIds[])
{
    if (mMetaEventId != 0 || mMetaEventType != PtEvent::META_EVENT_NONE)
        stopMetaEvent();

    mMetaEventId = metaEventId;
    mMetaEventType = metaEventType;

    if(mpMetaEventCallIds)
    {
        delete[] mpMetaEventCallIds;
        mpMetaEventCallIds = NULL;
    }

    if (numCalls > 0)
    {
        mNumMetaEventCalls = numCalls;
        mpMetaEventCallIds = new UtlString[numCalls];
        for(int i = 0; i < numCalls; i++)
        {
            if (metaEventCallIds)
                mpMetaEventCallIds[i] = metaEventCallIds[i];
            else
                mpMetaEventCallIds[i] = mCallId.data();
        }
    }
}

void CpCall::startMetaEvent(int metaEventId,
                            int metaEventType,
                            int numCalls,
                            const char* metaEventCallIds[],
                            int remoteIsCallee)
{
    setMetaEvent(metaEventId, metaEventType, numCalls, metaEventCallIds);
    postMetaEvent(METAEVENT_START, remoteIsCallee);
}

void CpCall::getMetaEvent(int& metaEventId, int& metaEventType,
                          int& numCalls, const UtlString* metaEventCallIds[]) const
{
    metaEventId = mMetaEventId;
    metaEventType = mMetaEventType;
    numCalls = mNumMetaEventCalls;
    *metaEventCallIds = mpMetaEventCallIds;
}

void CpCall::stopMetaEvent(int remoteIsCallee)
{
    postMetaEvent(METAEVENT_END, remoteIsCallee);

    // Clear the event info
    mMetaEventId = 0;
    mMetaEventType = PtEvent::META_EVENT_NONE;

    if(mpMetaEventCallIds)
    {
        delete[] mpMetaEventCallIds;
        mpMetaEventCallIds = NULL;
    }
}

void CpCall::setCallType(int callType)
{
    mCallType = callType;
}

int CpCall::getCallType() const
{
    return(mCallType);
}

void CpCall::setTargetCallId(const char* targetCallId)
{
    if(targetCallId && * targetCallId) mTargetCallId = targetCallId;
}

void CpCall::getTargetCallId(UtlString& targetCallId) const
{
    targetCallId = mTargetCallId;
}

void CpCall::setOriginalCallId(const char* originalCallId)
{
    if(originalCallId && * originalCallId) mOriginalCallId = originalCallId;
}

void CpCall::getOriginalCallId(UtlString& originalCallId) const
{
    originalCallId = mOriginalCallId;
}
/* ============================ INQUIRY =================================== */
UtlBoolean CpCall::isQueued()
{
    return(FALSE);
}

void CpCall::getLocalAddress(char* address, int maxLen)
{
   // :TODO: Not yet implemented.
   assert(FALSE);
}

void CpCall::getLocalTerminalId(char* terminal, int maxLen)
{
   // :TODO: Not yet implemented.
   assert(FALSE);
}

UtlBoolean CpCall::isCallIdSet()
{
    OsReadLock lock(mCallIdMutex);
    return(!mCallId.isNull());
}

UtlBoolean CpCall::isLocalHeld()
{
    return mLocalHeld;
}

/* //////////////////////////// PROTECTED ///////////////////////////////// */

void CpCall::addHistoryEvent(const char* messageLogString)
{
    mMessageEventCount++;
    mCallHistory[mMessageEventCount % CP_CALL_HISTORY_LENGTH] =
        messageLogString;
}

void CpCall::addHistoryEvent(const int msgSubType,
                             const CpMultiStringMessage* multiStringMessage)
{
    char eventDescription[100];
    UtlString subTypeString;
    CpCallManager::getEventSubTypeString((enum CpCallManager::EventSubTypes)msgSubType,
        subTypeString);
    UtlString msgDump;
    if(multiStringMessage) multiStringMessage->toString(msgDump, ", ");
    sprintf(eventDescription, " (%d) \n\t", msgSubType);
    addHistoryEvent(subTypeString + eventDescription + msgDump);
}

OsStatus CpCall::addListener(OsServerTask* pListener,
                             TaoListenerDb** pListeners,
                             int& listenerCnt,
                             char* callId,
                             int connectId,
                             int mask,
                             int pEv)
{
    for (int i = 0; i < listenerCnt; i++)
    {
        if (pListeners[i] &&
            pListeners[i]->mpListenerPtr == (int) pListener &&
            (!callId || pListeners[i]->mName.compareTo(callId) == 0) &&
            (pListeners[i]->mId == connectId))
        {
            pListeners[i]->mRef++;
            return OS_SUCCESS;