/*

* Copyright (c) 2009-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:

*      Implementation of packetdata Plugin interface.

*

*/

#include <stringloader.h>

#include <FeatMgr.h>

#include <centralrepository.h>

#include <CoreApplicationUIsSDKCRKeys.h>

#include "cmpluginpacketdata.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmpluginpacketdataTraces.h"

#endif

using namespace CMManager;

using namespace CommsDat;

// ================= CONSTANTS =======================

const TUint32 KDefaultPriorityPacketData = 1;

/// Modem bearer names for GPRS/WCDMA Access Points

_LIT( KModemBearerPacketData, "GPRS Modem" );

_LIT( KDefaultQosDataRecordName, "PRIMARY1" );

_LIT( KDefaultQosDataRecordNamewithSpace, "PRIMARY1 " );

const TInt KQosRecordIndex = 0;

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

/**

*  CCmPDCoverageCheck defines the functionality for packetdata service

*  coverage checking.

*/

class CCmPDCoverageCheck : public CActive

    {

    public:

        /**

         * Constructor.

         */

        CCmPDCoverageCheck();

        /**

         * Destructor.

         */

        ~CCmPDCoverageCheck();

        /**

         * Checks if the packet service is available(status is

         * ERegisteredOnHomeNetwork or ERegisteredRoaming or

         * ENotRegisteredButAvailable)

         * @return Return ETrue if the status is one mentioned above.

         * Otherwise returns EFalse.

         */

        TBool IsThereCoverageL();

    protected:  // from CActive

        virtual void DoCancel();

        virtual void RunL();

    private:

        /**

         * Ckecks if the phode mode is offline.

         * @return Returns ETrue if the phone is in offline mode.

         * Otherwise returns EFalse.

         */

        TBool IsPhoneOfflineL() const;

    private:

        /** Boolean which has the latest coverage information  */

        TBool                   iCoverage;

        /** Controller for single scheduling loop */

        CActiveSchedulerWait    iWait;

        /** Handle to telephony server */

        RTelServer              iServer;

        /** Handle to phone(needed for packet service) */

        RPhone                  iPhone;

        /** Handle to packet service */

        RPacketService          iService;

        /** Network registration status information */

        RPacketService::TRegistrationStatus iNwRegStatus;

    };

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

// CCmPDCoverageCheck::CCmPDCoverageCheck()

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

//

CCmPDCoverageCheck::CCmPDCoverageCheck() : CActive( EPriorityStandard )

    {

    OstTraceFunctionEntry0( CCMPDCOVERAGECHECK_CCMPDCOVERAGECHECK_ENTRY );

    CActiveScheduler::Add( this );

    OstTraceFunctionExit0( CCMPDCOVERAGECHECK_CCMPDCOVERAGECHECK_EXIT );

    }

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

// CCmPDCoverageCheck::~CCmPDCoverageCheck()

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

//

CCmPDCoverageCheck::~CCmPDCoverageCheck()

    {

    OstTraceFunctionEntry0( DUP1_CCMPDCOVERAGECHECK_CCMPDCOVERAGECHECK_ENTRY );

    Cancel();

    iService.Close();

    iPhone.Close();

    iServer.Close();

    OstTraceFunctionExit0( DUP1_CCMPDCOVERAGECHECK_CCMPDCOVERAGECHECK_EXIT );

    }

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

// CCmPDCoverageCheck::DoCancel

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

//

void CCmPDCoverageCheck::DoCancel()

    {

    OstTraceFunctionEntry0( CCMPDCOVERAGECHECK_DOCANCEL_ENTRY );

    iWait.AsyncStop();

    OstTraceFunctionExit0( CCMPDCOVERAGECHECK_DOCANCEL_EXIT );

    }

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

// CCmPDCoverageCheck::RunL

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

//

void CCmPDCoverageCheck::RunL()

    {

    OstTraceFunctionEntry0( CCMPDCOVERAGECHECK_RUNL_ENTRY );

    if ( iStatus.Int() == KErrNone )

        {

        if ( iNwRegStatus == RPacketService::ERegisteredOnHomeNetwork ||

             iNwRegStatus == RPacketService::ERegisteredRoaming ||

             iNwRegStatus == RPacketService::ENotRegisteredButAvailable )

            {

            iCoverage = ETrue;

            }

        iWait.AsyncStop();

        }

    else

        // something went wrong -> no coverage.

        {

        iWait.AsyncStop();

        }

    OstTraceFunctionExit0( CCMPDCOVERAGECHECK_RUNL_EXIT );

    }

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

// CCmPDCoverageCheck::IsThereCoverageL

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

//

TBool CCmPDCoverageCheck::IsThereCoverageL()

    {

    OstTraceFunctionEntry0( CCMPDCOVERAGECHECK_ISTHERECOVERAGEL_ENTRY );

    iCoverage = EFalse;

    if ( !IsPhoneOfflineL() )

        {

        User::LeaveIfError( iServer.Connect() );

        RTelServer::TPhoneInfo info;

        User::LeaveIfError( iServer.GetPhoneInfo( 0, info ) );

        User::LeaveIfError( iPhone.Open(iServer, info.iName ) );

        User::LeaveIfError( iService.Open( iPhone ) );

        iService.GetNtwkRegStatus( iStatus, iNwRegStatus );

        SetActive();

        iWait.Start();

        User::LeaveIfError( iStatus.Int() );

        }

    OstTraceFunctionExit0( CCMPDCOVERAGECHECK_ISTHERECOVERAGEL_EXIT );

    return iCoverage;

    }

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

// CCmPDCoverageCheck::IsPhoneOfflineL

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

//

TBool CCmPDCoverageCheck::IsPhoneOfflineL() const

    {

    OstTraceFunctionEntry0( CCMPDCOVERAGECHECK_ISPHONEOFFLINEL_ENTRY );

    if ( FeatureManager::FeatureSupported( KFeatureIdOfflineMode ) )

        {

        CRepository* repository = CRepository::NewLC( KCRUidCoreApplicationUIs );

        TInt connAllowed( ECoreAppUIsNetworkConnectionAllowed );

        repository->Get( KCoreAppUIsNetworkConnectionAllowed, connAllowed );

        CleanupStack::PopAndDestroy( repository );

        if ( !connAllowed )

            {

            OstTraceFunctionExit0( CCMPDCOVERAGECHECK_ISPHONEOFFLINEL_EXIT );

            return ETrue;

            }

        }

    OstTraceFunctionExit0( DUP1_CCMPDCOVERAGECHECK_ISPHONEOFFLINEL_EXIT );

    return EFalse;

    }

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

// CCmPluginPacketData::NewL

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

//

CCmPluginPacketData* CCmPluginPacketData::NewL(

        TCmPluginInitParam* aInitParam )

    {

    OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_NEWL_ENTRY );

    CCmPluginPacketData* self = new( ELeave ) CCmPluginPacketData( aInitParam, ETrue );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    OstTraceFunctionExit0( CCMPLUGINPACKETDATA_NEWL_EXIT );

    return self;

    }

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

// CCmPluginPacketData::~CCmPluginPacketData

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

//

CCmPluginPacketData::~CCmPluginPacketData()

    {

    OstTraceFunctionEntry1( CCMPLUGINPACKETDATA_CCMPLUGINPACKETDATA_ENTRY, this );

    ResetBearerRecords();

    FeatureManager::UnInitializeLib();

    OstTraceFunctionExit1( CCMPLUGINPACKETDATA_CCMPLUGINPACKETDATA_EXIT, this );

    }

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

// CCmPluginPacketData::CreateInstanceL

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

//

CCmPluginBaseEng* CCmPluginPacketData::CreateInstanceL( TCmPluginInitParam& aInitParam ) const

    {

    OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_CREATEINSTANCEL_ENTRY );

    CCmPluginPacketData* self = new( ELeave ) CCmPluginPacketData( &aInitParam, ETrue );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    OstTraceFunctionExit0( CCMPLUGINPACKETDATA_CREATEINSTANCEL_EXIT );

    return self;

    }

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

// CCmPluginPacketData::CCmPluginPacketData

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

//

CCmPluginPacketData::CCmPluginPacketData(

        TCmPluginInitParam* aInitParam,

        TBool aOutgoing )

        :

        CCmPluginBaseEng( aInitParam ),

        iOutgoing( aOutgoing )

    {

    OstTraceFunctionEntry0( DUP1_CCMPLUGINPACKETDATA_CCMPLUGINPACKETDATA_ENTRY );

    iBearerType = KUidPacketDataBearerType;

    iBearerRecordId = 0;

    iBearerRecordName = NULL;

    iPacketDataQoSRecord = NULL;

    OstTraceFunctionExit0( DUP1_CCMPLUGINPACKETDATA_CCMPLUGINPACKETDATA_EXIT );

    }

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

// CCmPluginPacketData::ConstructL

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

//

void CCmPluginPacketData::ConstructL()

    {

    OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_CONSTRUCTL_ENTRY );

    FeatureManager::InitializeLibL();

    CCmPluginBaseEng::ConstructL();

    OstTraceFunctionExit0( CCMPLUGINPACKETDATA_CONSTRUCTL_EXIT );

    }

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

// CCmPluginPacketData::CanHandleIapIdL()

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

//

TBool CCmPluginPacketData::CanHandleIapIdL( TUint32 aIapId ) const

    {

    OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_CANHANDLEIAPIDL_ENTRY );

    TBool retVal( EFalse );

    CCDIAPRecord *iapRecord = static_cast<CCDIAPRecord *>(

            CCDRecordBase::RecordFactoryL( KCDTIdIAPRecord ) );

    CleanupStack::PushL( iapRecord );

    iapRecord->SetRecordId( aIapId );

    TRAPD( err, iapRecord->LoadL( iSession ));

    if ( !err )

        {

        retVal = CanHandleIapIdL( iapRecord );

        }

    CleanupStack::PopAndDestroy( iapRecord );

    OstTraceFunctionExit0( CCMPLUGINPACKETDATA_CANHANDLEIAPIDL_EXIT );

    return retVal;

    }

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

// CCmPluginPacketData::CanHandleIapIdL()

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

//

TBool CCmPluginPacketData::CanHandleIapIdL( CCDIAPRecord *aIapRecord ) const

    {

    OstTraceFunctionEntry0( DUP1_CCMPLUGINPACKETDATA_CANHANDLEIAPIDL_ENTRY );

    TBool retVal( EFalse );

    if ( (TPtrC(aIapRecord->iServiceType) == TPtrC(KCDTypeNameOutgoingWCDMA) ||

            TPtrC(aIapRecord->iServiceType) == TPtrC(KCDTypeNameIncomingWCDMA)) &&

            TPtrC(aIapRecord->iBearerType) == TPtrC(KCDTypeNameModemBearer) )

        {

        retVal = ETrue;

        }

    OstTraceFunctionExit0( DUP1_CCMPLUGINPACKETDATA_CANHANDLEIAPIDL_EXIT );

    return retVal;

    }

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

// CCmPluginPacketData::PreparePluginToLoadRecordsL()

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

//

void CCmPluginPacketData::PreparePluginToLoadRecordsL()

    {

    }

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

// CCmPluginPacketData::PreparePluginToUpdateRecordsL

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

//

void CCmPluginPacketData::PreparePluginToUpdateRecordsL(

        RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,

        RPointerArray<CommsDat::CCDRecordBase>& aBearerSpecRecordArray )

    {

    OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_PREPAREPLUGINTOUPDATERECORDSL_ENTRY );

    CCDIAPRecord* iapRecord =

                static_cast<CCDIAPRecord*>( aGenRecordArray[KIapRecordIndex] );

    CCDWCDMAPacketServiceRecord* serviceRecord =

            static_cast<CCDWCDMAPacketServiceRecord*>( aGenRecordArray[KServiceRecordIndex] );

    CheckIfNameModifiedL( iapRecord, serviceRecord );

    CheckDNSServerAddressL( ETrue,

            serviceRecord->iGPRSIP6NameServer1,

            serviceRecord->iGPRSIP6NameServer2,

            serviceRecord->iGPRSIP6DNSAddrFromServer );

    CheckDNSServerAddressL( EFalse,

            serviceRecord->iGPRSIPNameServer1,

            serviceRecord->iGPRSIPNameServer2,

            serviceRecord->iGPRSIPDNSAddrFromServer );

    SetDaemonNameL( aGenRecordArray, aBearerSpecRecordArray );

    OstTraceFunctionExit0( CCMPLUGINPACKETDATA_PREPAREPLUGINTOUPDATERECORDSL_EXIT );

    }

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

// CCmPluginPacketData::SetDaemonNameL

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

//

void CCmPluginPacketData::SetDaemonNameL(

        RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,

        RPointerArray<CommsDat::CCDRecordBase>& aBearerSpecRecordArray )

    {

    OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_SETDAEMONNAMEL_ENTRY );

    // use DHCP if we can

    TBool ipfromSrv = GetBearerBoolAttributeL( EPacketDataIPAddrFromServer,

                                               aGenRecordArray,

                                               aBearerSpecRecordArray );

    if ( ipfromSrv )

        {

        SetBearerStringAttributeL( ECmConfigDaemonManagerName,

                                   KDaemonManagerName,

                                   aGenRecordArray,

                                   aBearerSpecRecordArray );

        SetBearerStringAttributeL( ECmConfigDaemonName,

                                   KConfigDaemonName,

                                   aGenRecordArray,

                                   aBearerSpecRecordArray );

        }

    else

        {

        if ( FeatureManager::FeatureSupported( KFeatureIdIPv6 ) )

            {

            SetBearerStringAttributeL( ECmConfigDaemonManagerName,

                                       KDaemonManagerName,

                                       aGenRecordArray,

                                       aBearerSpecRecordArray );

            SetBearerStringAttributeL( ECmConfigDaemonName,

                                       KConfigDaemonName,

                                       aGenRecordArray,

                                       aBearerSpecRecordArray );

            }

        else

            {

            SetBearerStringAttributeL( ECmConfigDaemonManagerName,

                                       KNullDesC(),

                                       aGenRecordArray,

                                       aBearerSpecRecordArray );

            SetBearerStringAttributeL( ECmConfigDaemonName,

                                       KNullDesC(),

                                       aGenRecordArray,

                                       aBearerSpecRecordArray );

            }

        }

    OstTraceFunctionExit0( CCMPLUGINPACKETDATA_SETDAEMONNAMEL_EXIT );

    }

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

// CCmPluginPacketData::LoadBearerRecordsL()

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

//

void CCmPluginPacketData::LoadBearerRecordsL()

    {

    OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_LOADBEARERRECORDSL_ENTRY );

    if ( ServiceRecord().iUmtsR99QoSAndOnTable )

        {

        iPacketDataQoSRecord = static_cast<CCDUmtsR99QoSAndOnTableRecord *>(

                CCDRecordBase::RecordFactoryL( KCDTIdUmtsR99QoSAndOnTableRecord ) );

        iPacketDataQoSRecord->SetRecordId( ServiceRecord().iUmtsR99QoSAndOnTable );

        iPacketDataQoSRecord->LoadL( iSession );

        }

    OstTraceFunctionExit0( CCMPLUGINPACKETDATA_LOADBEARERRECORDSL_EXIT );

    }

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

// CCmPluginPacketData::LoadServiceRecordL()

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

//

void CCmPluginPacketData::LoadServiceRecordL()

    {

    OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_LOADSERVICERECORDL_ENTRY );

    if ( TPtrC( KCDTypeNameOutgoingWCDMA ) == iIapRecord->iServiceType )

        {

        iServiceRecord = static_cast<CCDWCDMAPacketServiceRecord *>(

                CCDRecordBase::RecordFactoryL( KCDTIdOutgoingGprsRecord ) );

        iOutgoing = ETrue;

        }

    else if ( TPtrC( KCDTypeNameIncomingWCDMA ) == iIapRecord->iServiceType )

        {

        iServiceRecord = static_cast<CCDWCDMAPacketServiceRecord *>(

                CCDRecordBase::RecordFactoryL( KCDTIdIncomingGprsRecord ) );

        iOutgoing = EFalse;

        }

    else

        // this IAP service is not supported by this plugin.

        {

        User::Leave( KErrNotSupported );

        }

    iServiceRecord->SetRecordId( iIapRecord->iService );

    TRAPD( err, iServiceRecord->LoadL( iSession ) );

    if ( err == KErrNotFound )

        // record not found -> create a default one

        {

        CreateServiceRecordL();

        }

    OstTraceFunctionExit0( CCMPLUGINPACKETDATA_LOADSERVICERECORDL_EXIT );

    }

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

// CCmPluginPacketData::ServiceRecord()

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

//

CCDWCDMAPacketServiceRecord& CCmPluginPacketData::ServiceRecord() const

    {

    return *static_cast<CCDWCDMAPacketServiceRecord*>( iServiceRecord );