// Copyright (c) 2006-2009 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 "Cmmpacketservicetsy.h"

#include <ctsy/tflogger.h>

#include <ctsy/serviceapi/mmtsy_defaults.h>

#include "MmTsy_timeoutdefs.h"

#include "MmTsy_numberOfSlots.h"

#include "CMmCommonStaticUtility.h"

#include "Cmmpacketcontextlist.h"

#include "cmmpacketservicegsmwcdmaext.h"

#include "cmmcalllist.h"

#include "cmmcalltsy.h"

#include "CMmCustomTsy.h"

#include "CMmPacketTsy.h"

#include <ctsy/serviceapi/mmtsy_ipcdefs.h>

#include <ctsy/pluginapi/cmmdatapackage.h>

#include "cmmmbmscontextlist.h"

#include "cmmmbmsmonitoredlist.h"

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

CMmPacketServiceTsy::CMmPacketServiceTsy():

    iReqHandleType(EMultimodePacketServiceReqHandleUnknown)

    {

    }

CMmPacketServiceTsy* CMmPacketServiceTsy::NewL(

        CMmPhoneTsy* const aMmPhone,           

        CMmMessageManagerBase* const aMessageManager,

        MLtsyFactoryBase* aFactory  ) 

    {

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

    CMmPacketServiceTsy* const packetService =

        new ( ELeave ) CMmPacketServiceTsy();

    CleanupClosePushL( *packetService );

    packetService->iMmPhone = aMmPhone;

	packetService->iMessageManager = aMessageManager;

    packetService->ConstructL( aFactory );

    CleanupStack::Pop();

TFLOGSTRING("TSY: CMmPacketServiceTsy::NewL." );

    return packetService;

    }

void CMmPacketServiceTsy::ConstructL( MLtsyFactoryBase* aFactory )

    {

    InitModulesL( aFactory );

    InitStoresAndListsL();

	iMessageManager->RegisterTsyObject( CMmMessageManagerBase::EPacketDataTsy,

        this  );

    // Current Network Mode is initialized to be EMSClassUnknown

    iCurrentMode = RMobilePhone::ENetworkModeGsm;

    }

CMmPacketServiceTsy::~CMmPacketServiceTsy()

    {

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

    if ( iMmPhone )

        {

        // deregister tsy object from message manager

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

        // Reset packet data session pointer in phone

        iMmPhone->ResetPacketDataSession();

        }

    // Delete CMmTsyReqHandleStore object

    delete iTsyReqHandleStore;

    // Delete CMmPacketContextList object

    delete iPacketContextList;

    // Delete CMmPacketServiceGsmWcdmaExt object

    delete iMmPacketServiceGsmWcdmaExt;

    if(iMBMSContextList != NULL)

    	{

    	// Delete CMmMBMSContextList object

    	delete iMBMSContextList;

    	}

    if(iGetMbmsMonitoredServiceLists != NULL)

    	{

    	// Delete CArrayPtrFlat object

    	delete iGetMbmsMonitoredServiceLists;

    	}    

    if ( NULL != iDialUpContext )

        {

TFLOGSTRING("TSY: CMmPacketServiceTsy::~CMmPacketServiceTsy: Close Dial-up Object." );

        iDialUpContext->Close();

        }

    if ( NULL != iSecondaryDialUpContext )

        {

TFLOGSTRING("TSY: CMmPacketServiceTsy::~CMmPacketServiceTsy: Close Secondary Dial-up Object." );

        iSecondaryDialUpContext->Close();

        }

TFLOGSTRING("TSY: CMmPacketServiceTsy::~CMmPacketServiceTsy: Closing iMutex Object." );

    iMutex.Close();

#ifdef USING_CTSY_DISPATCHER

    //CTSY defect (memory leak) this maybe allocated, but it is never deleted.

    //no need for NULL check as C++ guarantees that operator delete checks its argument for null-ness.

    delete iMBMSMonitoredList;

    iMBMSMonitoredList = NULL;

#endif //USING_CTSY_DISPATCHER    

    }

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

// CMmPacketServiceTsy::InitModulesL

// Initialises extension modules for CMmPacketServiceTsy.

// if GSM flag is defined

// allocate memory for CMmPacketServiceGsmWcdmaExt object

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

//

void CMmPacketServiceTsy::InitModulesL( MLtsyFactoryBase* aFactory )

    {

    // Create Packet Service Gsm extension

    iMmPacketServiceGsmWcdmaExt =

        CMmPacketServiceGsmWcdmaExt::NewL( this, aFactory );

    }

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

// CMmPacketServiceTsy::InitStoresAndListsL

// Initialises needed stores and lists.

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

//

void CMmPacketServiceTsy::InitStoresAndListsL()

    {

#ifdef REQHANDLE_TIMER

    // Create req handle store

    iTsyReqHandleStore = CMmTsyReqHandleStore::NewL( this, iMmPhone,

        ENumOfMultimodePacketServiceRequests, iPacketServiceReqHandles );

#else

    // Create req handle store

    iTsyReqHandleStore = CMmTsyReqHandleStore::NewL(

        ENumOfMultimodePacketServiceRequests, iPacketServiceReqHandles );

#endif // REQHANDLE_TIMER

    // Create Packet Context List

    iPacketContextList = CMmPacketContextList::NewL( this );

    // create mbms context list 

    iMBMSContextList = CMmMBMSContextList::NewL();

    // create MBMS monitored service list

    iGetMbmsMonitoredServiceLists = new CArrayPtrFlat<CListReadAllAttempt>(1);

    // Set pointer to externally created dial-up context to be NULL

    iDialUpContext = NULL;

    // Set pointer to externally created dial-up context to be NULL

    iSecondaryDialUpContext = NULL;

    // Set phone not attached to the network

    iInternalSavedData.iServiceStatus = RPacketService::EStatusUnattached;

    // Current Mobile Station Class is initialized to be EMSClassUnknown

    iInternalSavedData.iMsClass = RPacketService::EMSClassUnknown;

    // If Gpds is suspended this flag is ETrue, otherwise EFalse

    iSuspended = EFalse;

    }

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

// CMmPacketServiceTsy::Init

// Initialisation method that is called from ETel Server.

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

//

void CMmPacketServiceTsy::Init()

    {

    }

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

// CMmPacketServiceTsy::CustomTsy

// Returns a pointer to Custom TSY object.

// return custom tsy owned by phone tsy

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

//

CMmCustomTsy* CMmPacketServiceTsy::CustomTsy() const

    {

    // Return custom tsy

    return iMmPhone->GetCustomTsy();

    }

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

// CMmPacketServiceTsy::ActivePacketServiceExtension

// Returns a pointer to the active packet service extension.

// The packet data extension implements functionality that is specific for

// selected mode. There should always be some extension active.

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

//

CMmPacketServiceGsmWcdmaExt* CMmPacketServiceTsy::ActivePacketServiceExtension()

    {

    // Return active packet service extension

    return iMmPacketServiceGsmWcdmaExt;

    }

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

// CMmPacketServiceTsy::TsyReqHandleStore

// Returns a pointer to the tsy request handle store.

// return tsy request handle store

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

//

CMmTsyReqHandleStore* CMmPacketServiceTsy::TsyReqHandleStore()

    {

    // Return tsy request handle store

    return iTsyReqHandleStore;

    }

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

// CMmPacketServiceTsy::IsContextStatusActive

// Checks if context status is active from service point of view

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

//

TBool CMmPacketServiceTsy::IsContextStatusActive(

    const RPacketContext::TContextStatus aContextStatus  ) const

    {

    if ( ( RPacketContext::EStatusActive == aContextStatus ) ||

         ( RPacketContext::EStatusDeactivating == aContextStatus ) )

        {

        // Context is active from the service point of view

        return ETrue;

        }

    return EFalse;

    }

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

// CMmPacketServiceTsy::UpdateAttachedPacketStatus

// Sets service status to active or attached and completes status changed

// notification to the client if needed.

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

//

void CMmPacketServiceTsy::UpdateAttachedPacketStatus(

    const TBool aIsActiveContext ) //is context active

    {

    TBool isActive( aIsActiveContext );

    // If external context exist and there are no active internal context

    if ( iDialUpContext != NULL && isActive == EFalse )

        {

        // If external context is active then active context found

        isActive = IsContextStatusActive( iDialUpContext->ContextStatus() );

        } 

    // If external context exist and there are no active internal context

    if ( iSecondaryDialUpContext != NULL && isActive == EFalse )

        {

        // If external context is active then active context found

        isActive = IsContextStatusActive( 

            iSecondaryDialUpContext->ContextStatus() );

        }

    if ( isActive && ( RPacketService::EStatusActive !=

         iInternalSavedData.iServiceStatus ) )

        {

        // Complete status change notification to the client and

        // set service status EStatusActive

        CMmPacketServiceTsy::CompleteNotifyStatusChange(

		    RPacketService::EStatusActive, KErrNone );

        }

    else if ( !isActive && ( RPacketService::EStatusAttached !=

              iInternalSavedData.iServiceStatus ) )

        {

        // Complete status change notification to the client and

        // set service status EStatusAttached

		CMmPacketServiceTsy::CompleteNotifyStatusChange(

		    RPacketService::EStatusAttached, KErrNone );

        }

TFLOGSTRING2("TSY: CMmPacketServiceTsy::UpdateAttachedPacketStatus. Service Status: %d", iInternalSavedData.iServiceStatus );

    }

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

// CMmPacketServiceTsy::CompletePacketStatusChanged

// Called from active extension to notify service that transfer status

// is changed.

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

//

void CMmPacketServiceTsy::CompletePacketStatusChanged(

    CMmDataPackage* aDataPackage,

    TInt aErrorCode )

    {

	RPacketService::TStatus packetStatus;

	TBool isresumed;

	TBool isActiveContext( EFalse );

	//Pack data

	aDataPackage->UnPackData( packetStatus, isresumed  );

    // Get number of created contexts

    const TInt numberOfContext( iPacketContextList->NumberOfContexts() );

    if ( isresumed )

        {

        // If current status is suspended

        if ( iSuspended )

            {

            CMmPacketContextTsy* packetContext;

            CMmMBMSContextTsy* mbmsContext;

            // check pdp context's

            for ( TInt i = 0; i < numberOfContext; i++ )

                {

                // Get context by index from context list

                packetContext = iPacketContextList->PacketContextByIndex( i );

                if ( NULL != packetContext )

                    {

                    // Inform context that service resumed from suspend

                    packetContext->ContextResumed();

                    }

                }

            // check mbms context's

            for ( TInt i = 0; i < iMBMSContextList->NumberOfContexts(); i++ )

                {

                // Get context by index from context list

                mbmsContext = iMBMSContextList->ContextByIndex( i );

                if ( NULL != mbmsContext )

                    {

                    // Inform context that service resumed from suspend

                    mbmsContext->ContextResumed();

                    }

                }                

            if ( iDialUpContext != NULL )

                {

TFLOGSTRING("TSY: CMmPacketServiceTsy::CompletePacketStatusChanged.  DialUp Context Resumed" );

                iDialUpContext->ContextResumed();

                }

            if ( iSecondaryDialUpContext != NULL )

                {

TFLOGSTRING("TSY: CMmPacketServiceTsy::CompletePacketStatusChanged. Secondary DialUp Context Resumed" );

                iSecondaryDialUpContext->ContextResumed();

                }

            // Get service status before suspend

            packetStatus = iInternalSavedData.iServiceStatusBeforeSuspend;

            // Current status is not suspended

            iSuspended = EFalse;

            }

        else

            {

            // Resumed without suspend, continue with current status

            packetStatus = iInternalSavedData.iServiceStatus;

            }

        }

    // If current status is not suspended or

    // current status is suspended and new status is unattached

    if ( !iSuspended || ( RPacketService::EStatusUnattached == packetStatus ) )

        {

        switch ( packetStatus )

            {

            case RPacketService::EStatusUnattached:

                if ( iSuspended )

                    {

                    // If previous status was suspended it is not valid 

                    // anymore

                    iSuspended = EFalse;

                    }

                // Complete status change notification with EStatusUnattached

                CMmPacketServiceTsy::CompleteNotifyStatusChange(

				    RPacketService::EStatusUnattached, aErrorCode );

                break;

            case RPacketService::EStatusAttached:

            case RPacketService::EStatusActive:

                CMmPacketContextTsy* packetContext;

                for ( TInt i = 0; i < numberOfContext; i++ )

                    {

                    packetContext =

                        iPacketContextList->PacketContextByIndex( i );

                    // If no active context found yet

                    if ( NULL != packetContext )

                        {

                        // Get context status

                        RPacketContext::TContextStatus contextStatus =

                            packetContext->ContextStatus();

                        // Check if context is active ( from service point 

                        // of view )

                        isActiveContext =

                            IsContextStatusActive( contextStatus );

                        }

                    if ( isActiveContext )

                        {

                        // Active context found, break

                        i = numberOfContext;

                        }

                    }

                // no active pdp context's, check if any mbms context is active

                if( !isActiveContext )

                    {

                    CMmMBMSContextTsy* mbmsContext;

                    // check mbms context's

                    for ( TInt i = 0; i < iMBMSContextList->NumberOfContexts(); i++ )

                        {

                        // Get context by index from context list

                        mbmsContext = iMBMSContextList->ContextByIndex( i );

                        if ( NULL != mbmsContext )

                            {

                            // Get context status

                            RPacketContext::TContextStatus contextStatus =

                                mbmsContext->ContextStatus();

                            // Check if context is active ( from service point 

                            // of view )

                            isActiveContext =

                                IsContextStatusActive( contextStatus );

                            }

                        if ( isActiveContext )

                            {

                            // Active context found, break

                            i = iMBMSContextList->NumberOfContexts();                                                   

                            }  

                        }

                    }

                // Update service status

                UpdateAttachedPacketStatus( isActiveContext );

                break;

            case RPacketService::EStatusSuspended:

                if ( !iSuspended && ( RPacketService::EStatusUnattached !=

                     iInternalSavedData.iServiceStatus ) )

                    {

                    // Save status before suspend internally

                    iInternalSavedData.iServiceStatusBeforeSuspend =

                        iInternalSavedData.iServiceStatus;

                    // Set iSuspended to be ETrue

                    iSuspended = ETrue;

                    CMmPacketContextTsy* packetContext;

                    for ( TInt i = 0; i < numberOfContext; i++ )

                        {

                        // Get next context

                        packetContext =

                            iPacketContextList->PacketContextByIndex( i );

                        if ( NULL != packetContext )

                            {

                            // Inform context that service is suspend

                            packetContext->ContextSuspended();

                            }

                        }