/*

* Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

// INCLUDE FILES

#include "cmmphonetsender.h"

#include "cmmconferencecallmesshandler.h"

#include "cmmstaticutility.h"

#include "cmmcallmesshandler.h"

#include "cmmmessagerouter.h"

#include "tsylogger.h"

#include "OstTraceDefinitions.h"

#include <etelmm.h>

#include <tisi.h>

#include <call_modemisi.h>

#include <ctsy/pluginapi/cmmdatapackage.h>

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmmconferencecallmesshandlerTraces.h"

#endif

// EXTERNAL DATA STRUCTURES

    // None

// EXTERNAL FUNCTION PROTOTYPES

    // None

// CONSTANTS

const TUint8 KConfCallPadding = 0x00; // Filler byte for ISI messages

// MACROS

    // None

// LOCAL CONSTANTS AND MACROS

    // None

// MODULE DATA STRUCTURES

    // None

// LOCAL FUNCTION PROTOTYPES

    // None

// ======================= LOCAL FUNCTIONS =====================================

    // None

// ==================== MEMBER FUNCTIONS =======================================

// -----------------------------------------------------------------------------

// CMmConferenceCallMessHandler::CMmConferenceCallMessHandler

// C++ default constructor

// -----------------------------------------------------------------------------

//

CMmConferenceCallMessHandler::CMmConferenceCallMessHandler()

    {

    // None

TFLOGSTRING("TSY: CMmConferenceCallMessHandler::CMmConferenceCallMessHandler");

    }

// -----------------------------------------------------------------------------

// CMmConferenceCallMessHandler::NewL

// Creates a new CMmConferenceCallMessHandler object instance.

// -----------------------------------------------------------------------------

//

CMmConferenceCallMessHandler* CMmConferenceCallMessHandler::NewL(

    CMmPhoNetSender* aPhoNetSender, //pointer to the phonet sender

    CMmPhoNetReceiver* aPhoNetReceiver, //pointer to the phonet receiver

    CMmMessageRouter* aMessageRouter// pointer to the message router

    )

    {

TFLOGSTRING("TSY: CMmConferenceCallMessHandler::NewL");

    CMmConferenceCallMessHandler* conferenceCallMessHandler =

        new ( ELeave ) CMmConferenceCallMessHandler();

    CleanupStack::PushL( conferenceCallMessHandler );

    conferenceCallMessHandler->iPhoNetSender = aPhoNetSender;

    conferenceCallMessHandler->iMessageRouter = aMessageRouter;

    conferenceCallMessHandler->ConstructL();

    aPhoNetReceiver->RegisterL(

        conferenceCallMessHandler,

        PN_MODEM_CALL,

        CALL_MODEM_CONTROL_IND );

    aPhoNetReceiver->RegisterL(

        conferenceCallMessHandler,

        PN_MODEM_CALL,

        CALL_MODEM_CONTROL_RESP );

    aPhoNetReceiver->RegisterL(

        conferenceCallMessHandler,

        PN_MODEM_CALL,

        CALL_MODEM_RELEASE_RESP );

    CleanupStack::Pop( conferenceCallMessHandler );

    return conferenceCallMessHandler;

    }

// -----------------------------------------------------------------------------

// CMmConferenceCallMessHandler::ConstructL

// Initialises object attributes.

// -----------------------------------------------------------------------------

//

void CMmConferenceCallMessHandler::ConstructL()

    {

TFLOGSTRING("TSY: CMmConferenceCallMessHandler::ConstructL");

    iIsCreateConference = EFalse;

    iLastOperation = 0;

    }

// -----------------------------------------------------------------------------

// CMmConferenceCallMessHandler::~CMmConferenceCallMessHandler

// C++ destructor

// -----------------------------------------------------------------------------

//

CMmConferenceCallMessHandler::~CMmConferenceCallMessHandler()

    {

TFLOGSTRING("TSY: CMmConferenceCallMessHandler::~CMmConferenceCallMessHandler");

    }

// -----------------------------------------------------------------------------

// CMmConferenceCallMessHandler::ExtFuncL

// Forwards requests coming from the Symbian OS layer to the

// specific method.

// -----------------------------------------------------------------------------

//

TInt CMmConferenceCallMessHandler::ExtFuncL(

    TInt aIpc,

    const CMmDataPackage* aDataPackage )

    {

TFLOGSTRING2("TSY: CMmConferenceCallMessHandler::ExtFuncL. Ipc:%d", aIpc);

    TInt ret( KErrNone );

    TUint8 transId( KConferenceCallTransId );

    switch( aIpc )

        {

        case EMobileConferenceCallAddCall:

            {

            // A CCallDataPackage is expected here

            const CCallDataPackage* callDataPackage =

                static_cast<const CCallDataPackage*>( aDataPackage );

            TUint8 isaCallId( CALL_MODEM_ID_NONE );

            TInt eTelCallId( KSymbianCallIdNone );

            RMobilePhone::TMobileService service(

                RMobilePhone::EServiceUnspecified );

            // Unpack ETel call ID parameter

            callDataPackage->GetCallIdAndMode( eTelCallId, service );

            // Map to ISA call ID

            isaCallId = MapETelCallIdToISACallId( eTelCallId );

            if ( CALL_MODEM_ID_NONE == isaCallId )

                {

                ret = KErrArgument;

                }

            else

                {

                ret = CallControlReq(

                    transId,

                    isaCallId,

                    CALL_MODEM_OP_CONFERENCE_BUILD,

                    EFalse );

                }

            break;

            }

        case EMobileConferenceCallCreateConference:

            {

            // No data to unpack

            ret = CallControlReq(

                transId,

                CALL_MODEM_ID_ACTIVE,

                CALL_MODEM_OP_CONFERENCE_BUILD,

                ETrue );

            break;

            }

        case EMobileConferenceCallSwap:

            {

            // No data to unpack

            ret = CallControlReq(

                transId,

                CALL_MODEM_ID_ACTIVE,

                CALL_MODEM_OP_SWAP,

                EFalse );

            break;

            }

        case EMobileConferenceCallHangUp:

            {

            // No data to unpack

            ret = CallReleaseReq(

                transId,

                CALL_MODEM_ID_CONFERENCE,

                CALL_MODEM_CAUSE_RELEASE_BY_USER );

            break;

            }

        // No DOS call is required for the following Conference Call IPCs:

        // Notifications

        case EMobileConferenceCallNotifyCapsChange:

        case EMobileConferenceCallNotifyConferenceStatusChange:

        case EMobileConferenceCallNotifyConferenceEvent:

        // Cancellations

        case EMobileConferenceCallNotifyCapsChangeCancel:

        case EMobileConferenceCallCreateConferenceCancel:

        case EMobileConferenceCallAddCallCancel:

        case EMobileConferenceCallSwapCancel:

        case EMobileConferenceCallHangUpCancel:

        case EMobileConferenceCallNotifyConferenceStatusChangeCancel:

        case EMobileConferenceCallNotifyConferenceEventCancel:

        // Query methods (do not change any state)

        case EMobileConferenceCallGetCaps:

        case EMobileConferenceCallEnumerateCalls:

        case EMobileConferenceCallGetMobileCallInfo:

        case EMobileConferenceCallGetConferenceStatus:

        default:

            {

TFLOGSTRING2("TSY: CMmConferenceCallMessHandler::ExtFuncL - Unknown IPC: %d", aIpc);

            ret = KErrNotSupported;

            break;

            }

        }

    return ret;

    }

// -----------------------------------------------------------------------------

// CMmConferenceCallMessHandler::MapETelCallIdToISACallId

// Utility function that maps an ETel call id to a call id

// in ISA Call Server's format.

// -----------------------------------------------------------------------------

//

TUint8 CMmConferenceCallMessHandler::MapETelCallIdToISACallId(

    const TInt aETelCallId )

    {

TFLOGSTRING("TSY: CMmConferenceCallMessHandler::MapETelCallIdToISACallId");

    TUint8 callId( CALL_MODEM_ID_NONE );

    if ( CALL_MODEM_ID_1 > aETelCallId || CALL_MODEM_ID_7 < aETelCallId )

        {

        callId = CALL_MODEM_ID_NONE;

        }

    else

        {

        callId = static_cast<TUint8>( aETelCallId );

        }

    return callId;

    }

// -----------------------------------------------------------------------------

// CMmConferenceCallMessHandler::ReceiveMessageL

// Called when an ISI message has been received.

// -----------------------------------------------------------------------------

//

void CMmConferenceCallMessHandler::ReceiveMessageL(

    const TIsiReceiveC& aIsiMsg )

    {

TFLOGSTRING("TSY: CMmConferenceCallMessHandler::ReceiveMessageL.");

    TInt resource( aIsiMsg.Get8bit( ISI_HEADER_OFFSET_RESOURCEID ) );

    TInt messageId( aIsiMsg.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) );

    switch( resource )

        {

        case PN_MODEM_CALL:

            {

            switch( messageId )

                {

                case CALL_MODEM_CONTROL_IND:

                    {

                    CallControlInd( aIsiMsg );

                    break;

                    }

                case CALL_MODEM_CONTROL_RESP:

                    {

                    CallControlResp( aIsiMsg );

                    break;

                    }

                case CALL_MODEM_RELEASE_RESP:

                    {

                    CallReleaseResp( aIsiMsg );

                    break;

                    }

                default:

                    {

TFLOGSTRING("TSY: CMmConferenceCallMessHandler::ReceiveMessageL. PN_CALL Switch messageID case default.");

                    break;

                    }

                }

            break; // Case PN_CALL

            }

        default:

            {

TFLOGSTRING("TSY: CMmConferenceCallMessHandler::ReceiveMessageL. Switch resource case default.");

            break;

            }

        }

    }

// -----------------------------------------------------------------------------

// CMmConferenceCallMessHandler::CallControlReq

// Sends Conference call related control requests to the Phonet

// -----------------------------------------------------------------------------

//

TInt CMmConferenceCallMessHandler::CallControlReq(

    TUint8 aTransactionId,

    TUint8 aCallId,

    TUint8 aOperation,

    TBool aIsCreateConference )

    {

TFLOGSTRING("TSY: CMmConferenceCallMessHandler::CallControlReq");

    // Data for ISI message

    TBuf8<2 + SIZE_CALL_MODEM_SB_OPERATION> messageBuf;

    messageBuf.Append( aCallId );

    messageBuf.Append( 1 ); // Number of Subblocks

    // Set value if this is conference call creation request or not.

    iIsCreateConference = aIsCreateConference;

    // Save control operation

    iLastOperation = aOperation;

    // Call control request sub blocks

    messageBuf.Append( CALL_MODEM_SB_OPERATION );

    messageBuf.Append( SIZE_CALL_MODEM_SB_OPERATION );

    messageBuf.Append( aOperation );

    // Call operation sub block, no operation info used

    messageBuf.Append( KConfCallPadding ); // Padding

    // Call conrol req

    // Send message via phonet

    return iPhoNetSender->Send(

        PN_MODEM_CALL,

        aTransactionId,

        CALL_MODEM_CONTROL_REQ,

        messageBuf );

    }

// -----------------------------------------------------------------------------

// CMmConferenceCallMessHandler::CallControlResp

// Breaks a CALL_MODEM_CONTROL_RESP ISI-message. Completes failed

// CreateConference, AddCall or Swap API request if there is a cause sub

// block in this response

// -----------------------------------------------------------------------------

//

void CMmConferenceCallMessHandler::CallControlResp(

    const TIsiReceiveC& aIsiMsg )

    {

TFLOGSTRING("TSY: CMmConferenceCallMessHandler::CallControlResp");

    TUint sbStartOffSet( 0 );

    // Try to find CALL_MODEM_SB_CAUSE subblock. If found something has gone wrong.

    if ( KErrNone == aIsiMsg.FindSubBlockOffsetById(

        ISI_HEADER_SIZE + SIZE_CALL_MODEM_CONTROL_RESP,

        CALL_MODEM_SB_CAUSE,

        EIsiSubBlockTypeId8Len8,

        sbStartOffSet ) )

        {

        // CALL_CAUSE sub block found, something has gone wrong.

        // Get cause type

        TUint8 causeType( aIsiMsg.Get8bit(

            sbStartOffSet + CALL_MODEM_SB_CAUSE_OFFSET_CAUSETYPE ) );

        // Get cause value

        TUint8 causeValue( aIsiMsg.Get8bit(

            sbStartOffSet + CALL_MODEM_SB_CAUSE_OFFSET_CAUSE ) );

        // Get Symbian OS error value

        TInt result( CMmStaticUtility::CSCauseToEpocError(

            PN_MODEM_CALL,

            causeType,

            causeValue ) );

        // If last operation was build, CreateConference or AddCall was asked

        if ( CALL_MODEM_OP_CONFERENCE_BUILD == iLastOperation )

            {

            // Has CreateConference been requested last.

            if ( iIsCreateConference )

                {

                // Complete with error

                iMessageRouter->Complete(

                    EMobileConferenceCallCreateConference,

                    result );

                // Reset flag

                iIsCreateConference = EFalse;

                }

            else

                {

                // Must be response to AddCall request

                iMessageRouter->Complete(

                    EMobileConferenceCallAddCall,

                    result );

                }

            iLastOperation = 0;

            }

        // If last operation was hold or retrieve

        else if ( CALL_MODEM_OP_HOLD == iLastOperation ||

            CALL_MODEM_OP_RETRIEVE == iLastOperation )

            {

            // Complete swap with error

            iMessageRouter->Complete(

                EMobileConferenceCallSwap,

                result );

            }

        // No else

        }

    // No else

    }

// -----------------------------------------------------------------------------

// CMmConferenceCallMessHandler::CallControlInd

// Breaks a CALL_CONTROL_IND ISI-message. Completes failed

// CreateConference, AddCall or Swap API request if there is a cause sub

// block in this response. In case that this message contains Split operation

// sub block, inform ConferenceCallTsy that GoOneToOne handling has started

// -----------------------------------------------------------------------------

//

void CMmConferenceCallMessHandler::CallControlInd(

    const TIsiReceiveC& aIsiMsg )

    {

TFLOGSTRING("TSY: CMmConferenceCallMessHandler::CallControlInd");

    TUint sbStartOffSet( 0 );

    // Try to find CALL_MODEM_SB_CAUSE subblock. If found something has gone wrong

    if( KErrNone == aIsiMsg.FindSubBlockOffsetById(

        ISI_HEADER_SIZE + SIZE_CALL_MODEM_CONTROL_IND,

        CALL_MODEM_SB_CAUSE,

        EIsiSubBlockTypeId8Len8,

        sbStartOffSet ) )

        {

        // CALL_MODEM_SB_CAUSE sub block found, something has gone wrong.

        // Get cause type

        TUint8 causeType( aIsiMsg.Get8bit(

            sbStartOffSet + CALL_MODEM_SB_CAUSE_OFFSET_CAUSETYPE ) );

        // Get cause value

        TUint8 causeValue( aIsiMsg.Get8bit(

            sbStartOffSet + CALL_MODEM_SB_CAUSE_OFFSET_CAUSE ) );

        // Get Symbian OS error value

        TInt result( CMmStaticUtility::CSCauseToEpocError(

            PN_MODEM_CALL,

            causeType,

            causeValue ) );

        // If last operation was build, CreateConference or AddCall was asked

        if ( CALL_MODEM_OP_CONFERENCE_BUILD == iLastOperation )

            {

            // Has CreateConference been requested last.

            if ( iIsCreateConference )

                {

                // Complete with error

                iMessageRouter->Complete(

                    EMobileConferenceCallCreateConference,

                    result);

                // Reset flag

                iIsCreateConference = EFalse;

                }

            else

                {

                // Must be response to AddCall request

                iMessageRouter->Complete(

                    EMobileConferenceCallAddCall,

                    result );

                }

            iLastOperation = 0;

            }

        // if last operation was hold or retrieve

        else if ( CALL_MODEM_OP_HOLD == iLastOperation ||

            CALL_MODEM_OP_RETRIEVE == iLastOperation )

            {

            // Complete swap with error

            iMessageRouter->Complete(

                EMobileConferenceCallSwap,

                result );

            }

        // No else

        }

    // Successful operation handling for operations

    // Initiated bypassing the ETel (ghost operetion).

    else if ( !iIsCreateConference && 0 == iLastOperation )

        {

        TUint8 callOperation( 0 );

        // Get call Id (three bits (1-3) contain unique call ID)

        TInt uniqueCallId( static_cast<TInt>( aIsiMsg.Get8bit(

            ISI_HEADER_SIZE + CALL_MODEM_CONTROL_IND_OFFSET_CALLID )

            & KMaskBits1to3 ) );

        // Get call operation sub block

        if ( KErrNone == aIsiMsg.FindSubBlockOffsetById(

            ISI_HEADER_SIZE + CALL_MODEM_CONTROL_IND_OFFSET_OPERATION,

            CALL_MODEM_SB_OPERATION,

            EIsiSubBlockTypeId8Len8,

            sbStartOffSet ) )

            {