// 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 "cmmmbmscontexttsy.h"

#include "cmmmbmscontextlist.h"

#include "CMmPacketTsy.h"

#include <ctsy/tflogger.h>

#include "mbmstypes.h"

#include "MmTsy_timeoutdefs.h"

#include "MmTsy_numberOfSlots.h"

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

CMmMBMSContextTsy::CMmMBMSContextTsy()

    {        

    }

CMmMBMSContextTsy* CMmMBMSContextTsy::NewL(

        CMmPacketServiceTsy* aMmPacketService,                

        const TDes& aName,  

        const TUint8 aProxyId  ) 

    {

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

    CMmMBMSContextTsy* packetContext = new ( ELeave ) CMmMBMSContextTsy();

    CleanupClosePushL( *packetContext );    

    packetContext->ConstructL( aMmPacketService, aName, aProxyId );

    CleanupStack::Pop();

    return packetContext;

    }

void CMmMBMSContextTsy::ConstructL(CMmPacketServiceTsy* const aMmPacketService,                

							        const TDes& aName,  

							        TUint8 aProxyId)

	{

    iMmPacketService = aMmPacketService;

    iContextName = aName;

    iObjectId = aProxyId;

    iConfig = new ( ELeave ) RPacketMbmsContext::TContextConfigMbmsV1();

#ifdef REQHANDLE_TIMER   

    // Create req handle store

    iTsyReqHandleStore = CMmTsyReqHandleStore::NewL(  this,

        iMmPacketService->PhoneTsy(), EMaxNumOfMBMSContextRequests,

        iPacketContextReqHandles );

#else

        // Create req handle store

    iTsyReqHandleStore = CMmTsyReqHandleStore::NewL( 

        EMaxNumOfMBMSContextRequests, iPacketContextReqHandles );

#endif // REQHANDLE_TIMER

    iIsInitialiseAllowed = ETrue;

    iServicesArray = RPacketMbmsContext::CMbmsSession::NewL(); 

    iContextStatus = RPacketContext::EStatusUnknown;  

    }

CMmMBMSContextTsy::~CMmMBMSContextTsy()

    {

TFLOGSTRING2( "TSY: CMmMBMSContextTsy::~CMmMBMSContextTsy Context name: %S", &iContextName );

	if( iMmPacketService )

		{			

		iMmPacketService->MBMSContextList()->RemoveObject( this );

	    // Set Dynamic Caps

	    iMmPacketService->ActivePacketServiceExtension()->SetDynamicCapsFlag(

	        RPacketService::KCapsActivate, EFalse );

		}

    delete iServicesArray;

    iServicesArray = NULL;

    delete iTsyReqHandleStore;

    iTsyReqHandleStore = NULL;

    delete iConfig;

    iConfig = NULL;             

    delete iTempConfig;

    iTempConfig = NULL;

    }

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

// CMmMBMSContextTsy::ExtFunc

// TRAP's all CMmMBMSContextTsy related MM Packet API requests in case that

// they fail. This method functions only as a centralized TRAP for the

// DoExtFuncL method that does the actual mapping of IPC number to TSY method

// call.

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

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

//

TInt CMmMBMSContextTsy::ExtFunc( 

        TTsyReqHandle aTsyReqHandle, 

        TInt aIpc, 

        const TDataPackage& aPackage )  

    {

TFLOGSTRING3( "TSY: CMmMBMSContextTsy::ExtFunc. IPC: %d Context name:%S", aIpc, &iContextName );

    TInt ret( KErrNone );

    TInt trapError( KErrNone );

    // Reset last tsy request type

    iReqHandleType = EMultimodePacketMbmsReqHandleUnknown;

    // Set tsy request handle

    iTsyReqHandle = aTsyReqHandle;    

    // Trap the call of DoExtFuncL

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

    if ( KErrNone != trapError )

        {

        ReqCompleted( aTsyReqHandle, trapError );

        }

    else if ( KErrNone != ret )

        {

        ReqCompleted( aTsyReqHandle, ret );

        }

        {

#ifdef REQHANDLE_TIMER

        SetTypeOfResponse( iReqHandleType, aTsyReqHandle );

#else

        iTsyReqHandleStore->SetTsyReqHandle( iReqHandleType, aTsyReqHandle );

#endif // REQHANDLE_TIMER

        }

    return KErrNone;

    }

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

// CMmMBMSContextTsy::DoExtFuncL

// Packet Data specific functionality of CMmMBMSContextTsy::ExtFunc

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

//

TInt CMmMBMSContextTsy::DoExtFuncL( 

        TTsyReqHandle aTsyReqHandle,      

        TInt aIpc,      

        const TDataPackage& aPackage )   

    {

TFLOGSTRING3( "TSY: CMmMBMSContextTsy::DoExtFuncL. IPC: %d Handle:%d",

                aIpc, aTsyReqHandle );

    TInt ret( KErrNotSupported );

    TAny* dataPtr = aPackage.Ptr1();

    TAny* dataPtr2 = aPackage.Ptr2();

    switch ( aIpc )

        {

        case EPacketContextNotifyStatusChange:

            ret = NotifyStatusChange( 

                reinterpret_cast< RPacketContext::TContextStatus*>( dataPtr ) );

            break;

        case EPacketContextNotifyConfigChanged:

            ret = NotifyConfigChanged( 

                reinterpret_cast< TPacketDataConfigBase*>( dataPtr ) );

            break;

        case EPacketContextInitialiseContext:

            ret = InitialiseContextL( reinterpret_cast< RPacketContext::TDataChannelV2*>( dataPtr ));

            break;

        case EPacketContextSetConfig:

            ret = SetConfigL( 

                reinterpret_cast< TPacketDataConfigBase*>( dataPtr ) );

            break;

        case EPacketContextActivate:

            ret = ActivateL();

            break;

        case EPacketContextDeactivate:

            ret = DeactivateL();

            break;

        case EPacketContextDelete:

            ret = DeleteL();

            break;

        case EPacketContextGetStatus:

            ret = GetStatus( aTsyReqHandle, 

                reinterpret_cast< RPacketContext::TContextStatus*>( dataPtr ) );

            break;

        case EPacketContextGetConfig:

            ret = GetConfig( aTsyReqHandle, 

                reinterpret_cast< TPacketDataConfigBase*>( dataPtr ) );

            break;

        case EPacketContextGetLastErrorCause:

            ret = GetLastErrorCause( aTsyReqHandle, 

                reinterpret_cast< TInt*>( dataPtr ) );

            break;

		case EPacketContextUpdateMbmsSessionList:

            ret = UpdateMbmsSessionList( 

             reinterpret_cast< TMbmsAction*>( dataPtr ),        

             reinterpret_cast< TMbmsSessionId*>( dataPtr2 ) );

            break;

        case EPacketGetMbmsSessionListPhase1:

            ret = GetMbmsActiveServicesPhase1L( aTsyReqHandle,

                reinterpret_cast< RMobilePhone::TClientId*>( dataPtr ),

                reinterpret_cast< TInt*>( dataPtr2 ) );

            break;

        case EPacketGetMbmsSessionListPhase2:

            ret = GetMbmsActiveServicesPhase2L( aTsyReqHandle,

                reinterpret_cast< RMobilePhone::TClientId*>( dataPtr ),

                aPackage.Des2n()  );

            break;            

        // These requests currently not supported

        case EPacketContextLoanCommPort:

        case EPacketContextRecoverCommPort:

        case EPacketContextNotifyDataTransferred:

        case EPacketContextGetProfileName:

        case EPacketContextGetConnectionSpeed:

        case EPacketContextGetDataVolumeTransferred:

        case EPacketContextEnumeratePacketFilters:

        case EPacketContextGetPacketFilterInfo:

        case EPacketContextAddPacketFilter:

        case EPacketContextRemovePacketFilter:

        case EPacketContextModifyActiveContext:

        case EPacketContextGetDNSInfo:

        case EPacketAddMediaAuthorization:

        case EPacketRemoveMediaAuthorization:

        default:

            break;

        }

    return ret;

    }

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

// CMmMBMSContextTsy::ReqModeL

// Returns request mode for given IPC.

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

//

CTelObject::TReqMode CMmMBMSContextTsy::ReqModeL( 

        TInt aIpc ) 

    {

TFLOGSTRING2( "TSY: CMmMBMSContextTsy::ReqModeL. IPC: %d", aIpc );

    CTelObject::TReqMode reqMode( 0 );

    TBool doLeave( EFalse );

    switch ( aIpc )

        {

        // All disabled

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

        // all requests in this category.  

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

        // Flow control not required.

        case EPacketContextGetLastErrorCause:

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

        // Flow control not required.

        // 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 EPacketContextGetStatus:

        case EPacketContextGetConfig:

            break;

        // KReqModeFlowControlObeyed

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

        // counter, are commands that the TSY should only deal with one at 

        // a time.

        case EPacketContextUpdateMbmsSessionList:

        case EPacketContextInitialiseContext:

        case EPacketContextActivate:

        case EPacketContextDelete:

        case EPacketContextSetConfig:

        case EPacketContextAddPacketFilter:

        case EPacketContextRemovePacketFilter:

        case EPacketContextDeactivate:

            {

            reqMode = KReqModeFlowControlObeyed;

            break;

            }

        // 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.

        case EPacketContextNotifyConfigChanged:

        case EPacketContextNotifyStatusChange:

            reqMode = KReqModeMultipleCompletionEnabled |

                KReqModeRePostImmediately;

            break;

        case EPacketGetMbmsSessionListPhase1:

        case EPacketGetMbmsSessionListPhase2:

            reqMode = 0;

            break;

        // Cancel Requests

        // It's 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.

        // Following requests are not supported

        //case EPacketContextNotifyDataTransferred:

        //case EPacketContextLoanCommPort:

        //case EPacketContextRecoverCommPort:

        //case EPacketContextModifyActiveContext:

        // Default

        default:

            doLeave = ETrue;

            break;

        }

    if ( doLeave )

        {

        User::Leave( KErrNotSupported );

        }

    return reqMode;

    }

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

// CMmMBMSContextTsy::NumberOfSlotsL

// Returns number of slots to be used for given IPC.

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

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

//

TInt CMmMBMSContextTsy::NumberOfSlotsL(    

        TInt aIpc )                            

    {

    TInt numberOfSlots( 0 );

    switch ( aIpc )

        {

        case EPacketContextNotifyStatusChange:

            numberOfSlots = KMmPacketContextNotifyStatusChangeSlots;

            break;

        case EPacketContextNotifyConfigChanged:

            numberOfSlots = KMmPacketContextNotifyConfigChangedSlots;

            break;

        default:

            // Unknown or invalid IPC

            User::Leave( KErrNotSupported );

            break;

        }  

TFLOGSTRING3( "TSY: CMmMBMSContextTsy::NumberOfSlotsL. IPC: %d Number of slots: %d", aIpc, numberOfSlots );

    return numberOfSlots;

    }

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

// CMmMBMSContextTsy::CancelService

// Cancel the outstanding request.ETel Server when it is "cleaning-up" any

//  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 Packet API requests are handled 

//  here. Client can also cancel a request by calling CancelAsyncRequest 

//  (defined in etel.h). The ETel server passes this kind of cancel requests

//  to CancelService.

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

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

//

TInt CMmMBMSContextTsy::CancelService(    

        TInt aIpc,                            

        TTsyReqHandle aTsyReqHandle )         

    {

TFLOGSTRING3( "TSY: CMmMBMSContextTsy::CancelService. IPC: %d Handle:%d", aIpc, aTsyReqHandle );

    TInt ret( KErrNone );

	//TTsyReqHandle reqHandle( NULL );

    // Reset last tsy request type

    iReqHandleType = EMultimodePacketMbmsReqHandleUnknown;

    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 EPacketContextUpdateMbmsSessionList:

        case EPacketContextInitialiseContext:

        case EPacketContextActivate:

        case EPacketContextDeactivate:

        case EPacketContextDelete:

        case EPacketContextSetConfig:

        case EPacketContextGetConfig:

            break;

        case EPacketGetMbmsSessionListPhase1:

            ret = CancelGetMbmsActiveServicesPhase1();

            break;

        // Notification Cancels, no special requirements.

        case EPacketContextNotifyStatusChange:

            iRetNotifyStatus = NULL;

            iReqHandleType = EMultimodeMbmsContextNotifyStatusChange;

            break;

        case EPacketContextNotifyConfigChanged:

            iRetNotifyConfig = NULL;

            iReqHandleType = EMultimodeMbmsContextNotifyConfigChanged;

            break;

        // IPCs that are not supported

        //case EPacketContextLoanCommPort:

        //case EPacketContextRecoverCommPort:

        //case EPacketContextNotifyDataTransferred:

        //case EPacketContextModifyActiveContext:

        // Default

        default:

            ret = KErrNotSupported;

            break;

        }

    if ( EMultimodePacketMbmsReqHandleUnknown != iReqHandleType )

        {

        // Reset tsy request handle

        iTsyReqHandleStore->ResetTsyReqHandle( iReqHandleType );

        // Complete request

        CMmMBMSContextTsy::ReqCompleted( aTsyReqHandle, KErrCancel );

        }

    return ret;

    }

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

// CMmMBMSContextTsy::RegisterNotification

// Register notification. RegisterNotification is called when the ETel Server

// recognises that this notification is being posted for the first time on

// this subsession object.It enables the TSY to "turn on" any regular 

// notification messages that it may receive from DOS. If this object is

// Dial-Up context only supported notification is 

// EPacketContextNotifyStatusChange.

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

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

//

TInt CMmMBMSContextTsy::RegisterNotification( 

        TInt aIpc )              

    {

TFLOGSTRING2( "TSY: CMmMBMSContextTsy::RegisterNotification. IPC: %d", aIpc );

    TInt ret( KErrNone );

    switch ( aIpc )

        {

        case EPacketContextNotifyConfigChanged:

        case EPacketContextNotifyStatusChange:

            break;

        //case EPacketContextNotifyDataTransferred:

        default:

            // Not supported

            ret = KErrNotSupported;

            break;

        }

    return ret;

    }

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

// CMmMBMSContextTsy::DeregisterNotification

// Deregister notification. DeregisterNotification is called when the ETel

// Server recognises that this notification will not be posted again because 

// the last client to have a handle on this sub-session object has just closed 

// the handle. It enables the TSY to "turn off" any regular notification

// messages that it may receive from DOS. If this object is Dial-Up context

// only supported notification is EPacketContextNotifyStatusChange.

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

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

//

TInt CMmMBMSContextTsy::DeregisterNotification(

        TInt aIpc )                          

    {

TFLOGSTRING2( "TSY: CMmMBMSContextTsy::DeregisterNotification. IPC: %d", aIpc );

    TInt ret( KErrNone );

    switch ( aIpc )

        {

        case EPacketContextNotifyConfigChanged:

        case EPacketContextNotifyStatusChange:

            break;

        //case EPacketContextNotifyDataTransferred:

        default:

            // Not supported

            ret = KErrNotSupported;

            break;

        }

    return ret;

    }

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

// CMmMBMSContextTsy::InitialiseContextL

// This function initialises the context created previously.

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

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

//

TInt CMmMBMSContextTsy::InitialiseContextL( RPacketContext::TDataChannelV2* aDataChannel )

    {

TFLOGSTRING2( "TSY: CMmMBMSContextTsy::InitialiseContextL. %S", &iContextName );