// Copyright (c) 2006-2010 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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 "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmmconferencecalltsyTraces.h"

#endif

#include "cmmconferencecalltsy.h"

#include "cmmphonetsy.h"

#include "cmmtsyreqhandlestore.h"

#include "MmTsy_numberOfSlots.h"

#include "CMmCommonStaticUtility.h"

#include "cmmconferencecallgsmwcdmaext.h"

#include "cmmvoicecalltsy.h"

#include "cmmcallgsmwcdmaext.h"

#include "cmmcalllist.h"

#include "cmmmessagemanagerbase.h"

#include <ctsy/serviceapi/gsmerror.h>

#include <etelmmerr.h> // etel error codes

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

CMmConferenceCallTsy::CMmConferenceCallTsy():

    iReqHandleType(EMultimodeConferenceCallReqHandleUnknown)

    {

    }

CMmConferenceCallTsy* CMmConferenceCallTsy::NewL(

    CMmPhoneTsy* aMmPhone )

    {

    CMmConferenceCallTsy* conferenceCallTsy = NULL;

    if ( aMmPhone != NULL )

        {

        conferenceCallTsy  = new (ELeave) CMmConferenceCallTsy();

        CleanupClosePushL( *conferenceCallTsy );

        conferenceCallTsy->iMmPhone = aMmPhone;

        conferenceCallTsy->ConstructL();

        CleanupStack::Pop();

        }

    return conferenceCallTsy;

    }

void CMmConferenceCallTsy::ConstructL()

    {

#ifdef REQHANDLE_TIMER

    //create req handle store

    iTsyReqHandleStore = CMmTsyReqHandleStore::NewL( this, iMmPhone,

        EMultimodeConferenceCallMaxNumOfRequests, iConferenceCallReqHandles );

#else

    //create req handle store

    iTsyReqHandleStore = CMmTsyReqHandleStore::NewL(

        EMultimodeConferenceCallMaxNumOfRequests, iConferenceCallReqHandles );

#endif

    //Create conference call extension

    iMmConferenceCallExtInterface = 

                                CMmConferenceCallGsmWcdmaExt::NewL( this );

    //Initialise internal attributes...

    ResetAttributes();

    //Check if conference call creation is already possible. If possible,

    //capabilities are updated by the extension.

    CheckConferenceCapability();

    //register conference call tsy in the message manager

    iMmPhone->MessageManager()->RegisterTsyObject(

        CMmMessageManagerBase::EConferenceCallTsy, this );

    }

CMmConferenceCallTsy::~CMmConferenceCallTsy()

    {

    OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CMMCONFERENCECALLTSY_DTOR_1, "TSY: CMmConferenceCallTsy::~CMmConferenceCallTsy");

    if ( iMmPhone )

        {

        // deregister tsy object from message manager

        iMmPhone->MessageManager()->DeregisterTsyObject(this);        

        //set phone tsy's pointer to CC object to NULL

        iMmPhone->SetConferenceCall( NULL );

        }

    //if conference is active, close all calls that are part of the conference 

    //call. send request using transaction id 0x00.

    if ( RMobileConferenceCall::EConferenceIdle != iStatus )

        {

        //We can't do nothing if release request fails here, because CC

        //sub-session is closing down.

		TInt trapError = KErrNone;

		TRAP( trapError, 

	        iMmConferenceCallExtInterface->HangUpL( iStatus );

			);

        }

    if ( iTsyReqHandleStore )

        {

        delete iTsyReqHandleStore;

        }

    //delete conference call extensions

    if ( iMmConferenceCallExtInterface )

        {

        delete iMmConferenceCallExtInterface;

        }

	iMmConferenceCallExtInterface = NULL;

	iMmPhone = NULL;

	iTsyReqHandleStore = NULL;

	iRetCaps = NULL;

	iRetStatus = NULL;

	iRetConferenceEventCallName = NULL;

	iRetConferenceEvent = NULL;

	iConnectedCall = NULL;

	iHoldCall = NULL;

    }

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

// CMmConferenceCallTsy::OpenNewObjectByNameL

// This method is not supported.

// (other items were commented in a header).

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

//

CTelObject* CMmConferenceCallTsy::OpenNewObjectByNameL(

    const TDesC& )

    {

    User::Leave( KErrNotSupported );

	//lint -e{527} "unreachable code"

    return NULL;

    }

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

// CMmConferenceCallTsy::OpenNewObjectL

// This method is not supported.

// (other items were commented in a header).

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

//

CTelObject* CMmConferenceCallTsy::OpenNewObjectL(

    TDes& )

    {

    User::Leave( KErrNotSupported );

    return NULL;

    }

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

// CMmConferenceCallTsy::ExtFunc

// Dispatches extension function requests. All functions that are not 

// part of the core function set, are routed via the ExtFunc method. 

// At the beginning of this method, packaged pointers are unpacked. Then 

// the correct function is selected using the IPC number.

// (other items were commented in a header).

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

//

TInt CMmConferenceCallTsy::ExtFunc(

    const TTsyReqHandle aTsyReqHandle,

    const TInt aIpc,

    const TDataPackage& aPackage )

    {

    TInt ret( KErrNone );

    TInt trapError( KErrNone );

    // Ensure the ReqHandleType is unset.

    // This will detect cases where this method indirectly calls itself

    // (e.g. servicing a client call that causes a self-reposting notification to complete and thus repost).

    // Such cases are not supported because iReqHandleType is in the context of this class instance,

    // not this request, and we don't want the values set by the inner request and the outer request

    // interfering with each other.

    __ASSERT_DEBUG(iReqHandleType==EMultimodeConferenceCallReqHandleUnknown, User::Invariant());

    //Original code continues here.

    TRAP( trapError, ret = DoExtFuncL( aTsyReqHandle, aIpc, aPackage ); );

    if ( trapError != KErrNone )

        {

        //error handling. Object cannot be created.

		//reset request handle to indicate the request is no longer ongoing

        iTsyReqHandleStore->FindAndResetTsyReqHandle(aTsyReqHandle);

        ReqCompleted( aTsyReqHandle, trapError );

        }

    //if return value is not KErrNone

    else if ( ret != KErrNone )

        {

        //Complete request with this error value

        ReqCompleted( aTsyReqHandle, ret );

        }

    else if ( EMultimodeConferenceCallReqHandleUnknown != iReqHandleType )

        {

        //save request handle

#ifdef REQHANDLE_TIMER

        SetTypeOfResponse ( iReqHandleType, aTsyReqHandle );

#else

        iTsyReqHandleStore->SetTsyReqHandle( iReqHandleType, aTsyReqHandle );

#endif

        }

    // We've finished with this value now. Clear it so it doesn't leak

    //  up to any other instances of this method down the call stack

    iReqHandleType = EMultimodeConferenceCallReqHandleUnknown;

    return KErrNone;

    }

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

// CMmConferenceCallTsy::DoExtFuncL

// ExtFunc is called by the server when it has a "extended", 

// i.e. non-core ETel request for the TSY. To process a request handle, 

// request type and request data are passed to the TSY.

// (other items were commented in a header).

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

//

TInt CMmConferenceCallTsy::DoExtFuncL(

    const TTsyReqHandle aTsyReqHandle,

    const TInt aIpc,

    const TDataPackage& aPackage )

    {

    TInt ret( KErrNotSupported );

    TAny* dataPtr = aPackage.Ptr1();

    // The request data has to extracted from TDataPackage and the TAny* 

    // pointers have to be "cast" to the expected request data type

    switch( aIpc )

        {     

        case EMobileConferenceCallGetCaps:

            ret = GetCaps( aTsyReqHandle, 

                reinterpret_cast<TUint32*>( dataPtr ) );

            break;

        case EMobileConferenceCallNotifyCapsChange:

            ret = NotifyCapsChange( reinterpret_cast<TUint32*>( dataPtr ) );

            break;

        case EMobileConferenceCallCreateConference:

            ret = CreateConferenceL( aTsyReqHandle );

            break;

        case EMobileConferenceCallAddCall:

            ret = AddCallL( aTsyReqHandle, 

				reinterpret_cast<TName*>( aPackage.Des1u() ) );

            break;

        case EMobileConferenceCallSwap:

            ret = SwapL( aTsyReqHandle );

            break;

        case EMobileConferenceCallHangUp:

            ret = HangUpL( aTsyReqHandle );

            break;

        case EMobileConferenceCallEnumerateCalls:

            ret = EnumerateCalls( aTsyReqHandle, 

                reinterpret_cast<TInt*>( dataPtr ) );

            break;

        case EMobileConferenceCallGetMobileCallInfo:

            ret = GetMobileCallInfo( aTsyReqHandle, 

                reinterpret_cast<TInt*>( dataPtr ),

                aPackage.Des2n() );

            break;

        case EMobileConferenceCallGetConferenceStatus:

            ret = GetConferenceStatus( aTsyReqHandle, 

				reinterpret_cast<RMobileConferenceCall::TMobileConferenceStatus*>(

					dataPtr ) );

            break;

        case EMobileConferenceCallNotifyConferenceStatusChange:

            ret = NotifyConferenceStatusChange(

				reinterpret_cast<RMobileConferenceCall::TMobileConferenceStatus*>(

					dataPtr ) );

            break;

        case EMobileConferenceCallNotifyConferenceEvent:

            ret = NotifyConferenceEvent(

				reinterpret_cast<RMobileConferenceCall::TMobileConferenceEvent*>(

					dataPtr ), reinterpret_cast<TName*>( aPackage.Des2u() ) );

            break;

        default:

            ret = KErrNotSupported;

            break;

        }

    return ret;

    }

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

// CMmConferenceCallTsy::ReqModeL

// ReqModeL is called from the server's CTelObject::ReqAnalyserL

// in order to check the type of request it has.

// (other items were commented in a header).

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

//

CTelObject::TReqMode CMmConferenceCallTsy::ReqModeL(

    const TInt aIpc )

    {

    CTelObject::TReqMode ret( 0 ); // default return value

    switch ( aIpc )

        {

        // No Flow Control

        // All disabled

        // TSYs wishing to implement their own buffering algorithm will place

        // all requests in this category.

        // This category will also be used by the RecoverDataPort request that

        // must be passed to the TSY to indicate that it may use the

        // communications port after a loan.

        //Get methods that do not use DOS and return immediately.

        //Flow control not required.

        case EMobileConferenceCallGetCaps:

        case EMobileConferenceCallGetMobileCallInfo:

        case EMobileConferenceCallGetConferenceStatus:

        //Other methods that do not use DOS and return immediately.

        //Flow control not required.        

        case EMobileConferenceCallEnumerateCalls:

        //Methods that can propably take a long time and cannot therefore be

        //flow controlled. Solution: All these methods must check req handle

        //table before handling the request. In case that the request table

        //indicates that same method has been called and has not been

        //completed, the method should return KErrServerBusy.

        case EMobileConferenceCallHangUp:

            break;

        // Flow Controlled Services

        // KReqModeFlowControlObeyed

        // Commands that change the state of the phone, e.g. clearing the AoC

        // counter; are commands that TSY should only deal with one at a time.

        //Voice call related methods that should be handled only

        //one at the time.

        case EMobileConferenceCallCreateConference:

        case EMobileConferenceCallSwap:

        case EMobileConferenceCallAddCall:

            ret = KReqModeFlowControlObeyed;

            break;

        // ReqModePostImmediately

        // Requests that notify a client about a change of state, where the 

        // TSY needs to distinguish between different clients.

        //*******************************************************************

        // (TAN) DO NOT USE THIS if not absolutely certain how to handle the 

        // corresponding method in TSY. Differs from all other situations!!! 

        //********************************************************************

            //ret=KReqModeRePostImmediately;

        // KReqModeMultipleCompletionEnabled

        // (a) commands that may take some time, but which the TSY can handle

        // more than one of concurrently, or 

        // (b) notifications that the TSY does not wish to be re-posted

        // immediately, so the server does no buffering.

            //ret=KReqModeMultipleCompletionEnabled;

        // KReqModeMultipleCompletionEnabled | KReqModeFlowControlObeyed

        // A command that may take some time and which the TSY can only deal

        // with one at a time.

        //case EEtelCallSetFaxSettings:

        //    ret = KReqModeMultipleCompletionEnabled |

        //        KReqModeFlowControlObeyed;

        //    break;

        //Notifications

        //KReqModeMultipleCompletionEnabled | ReqModePostImmediately

        //Requests that notify a client about a change of state.

        //Since these requests do not require the issuing of any modem

        //commands, they do not have to obey flow control.

        //The TSY never gets more than one of these outstanding per CTelObject

        case EMobileConferenceCallNotifyCapsChange:

        case EMobileConferenceCallNotifyConferenceStatusChange:

        case EMobileConferenceCallNotifyConferenceEvent:

            ret = KReqModeMultipleCompletionEnabled | 

                                                    KReqModeRePostImmediately;

            break;

        //Cancel Requests

        //It is not necessary to include the Cancel methods in ReqModeL at all

        //The ETel server never calls ReqModeL with a Cancel IPC.

        // Other variations of return values are unusable

        default:

            // Unknown or invalid Call IPC

            User::Leave( KErrNotSupported );

            break;

        }

    return ret;

    }

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

// CMmConferenceCallTsy::NumberOfSlotsL

// NumberOfSlotsL is called by the server when it is registering a 

// new NOTIFICATION. It enables the TSY to tell the server 

// how many buffer slots to allocate for "repost immediately" notifications 

// that may trigger before clients collect them.

// (other items were commented in a header).

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

//

TInt CMmConferenceCallTsy::NumberOfSlotsL(

    const TInt aIpc )

    {

    // There is a buffer in the ETel server for each type of NOTIFICATION and

    // the size of the buffer is determined by the TSY. When the ETel server

    // discovers that a request is "repost immediately" it will ask the TSY 

    // how big a buffer it wants by calling CTelObject::NumberOfSlotsL( ).

    //

    // It is up to the TSY developer's judgement how many buffer slots this

    // method returns for each notification. If there is a danger that a

    // particular notification could trigger frequently and in rapid 

    // succession (e.g. call group change notification) then at least 10 or 20 

    // slots may be required. For a notification that triggers rarely, perhaps 

    // 1 or 2 slots is enough.

    //

    // So if the ETel server has stored a few occurrences of a particular

    // notification, when client subsequently calls that notification request,

    // the ETel server will complete the client's request with the saved data.

    TInt numberOfSlots = 1;

    switch ( aIpc ) 

        {

        case EMobileConferenceCallNotifyCapsChange:

            numberOfSlots = KMmConferenceCallCapsChangeSlots;

            break;

        case EMobileConferenceCallNotifyConferenceStatusChange:

            numberOfSlots = KMmConferenceCallStatusChangeSlots;

            break;

        case EMobileConferenceCallNotifyConferenceEvent:

            numberOfSlots = KMmConferenceCallEventSlots;

            break;

        default:

            // Unknown or invalid Call IPC

            User::Leave( KErrNotSupported );

            break;

        }

    return numberOfSlots;

    }

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

// CMmConferenceCallTsy::CancelService

// CancelService is called by the server when it is 

// "cleaning-up" any still outstanding asynchronous requests before closing 

// a client's sub-session. This will happen if a client closes its R-class 

// handle without cancelling outstanding asynchronous requests. Only 

// Mobile API requests are handled here.

// (other items were commented in a header).

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

//

TInt CMmConferenceCallTsy::CancelService(

    const TInt aIpc,

    const TTsyReqHandle aTsyReqHandle )

    {

    //When the clients close their sub-sessions (eg. by calling RPhone::Close)

    //they may not have cancelled all their outstanding asynchronous requests

    //before closing. It is up to the ETel server to clean up in this

    //situation, so the server will find the list of outstanding requests

    //related to that sub-session object and pass these outstanding IPC req.

    //numbers, one at a time, to the CancelService function in the TSY.

    TInt ret( KErrNone );

    switch( aIpc )

        {

        //TSY has started a request and it is not possible to then cancel

        //this request. The best thing for the TSY to do in this case is

        //to proceed as though the Cancel never happened. The server's call

        //to the TSY cancel function will return synchronously. The TSY then

        //continues to wait for the original acknowledgement and when it

        //receives it, the TSY will complete the original request.

        case EMobileConferenceCallCreateConference:

        case EMobileConferenceCallAddCall:

        case EMobileConferenceCallSwap:

        case EMobileConferenceCallHangUp:

            break;

        //Cancel methods that are not supported

        //case XXX

        //    ret = KErrNotSupported;

        //    break;

        //Notification Cancels, no special requirements.

        case EMobileConferenceCallNotifyCapsChange:

            ret = NotifyCapsChangeCancel( aTsyReqHandle );

            break;

        case EMobileConferenceCallNotifyConferenceStatusChange:

            ret = NotifyConferenceStatusChangeCancel( aTsyReqHandle );

            break;

        case EMobileConferenceCallNotifyConferenceEvent:

            ret = NotifyConferenceEventCancel( aTsyReqHandle );

            break;

        //Everything is taken care in the method implementation.

        //Just direct the request to the method.

        //case

        //  none

        //Default case

        default:

            ret = KErrNotFound;

            break;

        }

    return ret;

    }