/*

* Copyright (c) 2006 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 CNcdProtocol

*

*/

#include "ncdprotocolimpl.h"

#include "ncdparserfactory.h"

#include "ncdparser.h"

#include "ncdsessionhandler.h"

#include "catalogsdebug.h"

#include "ncdrequestbase.h"

#include "ncddeviceinteractionfactory.h"

#include "ncddeviceservice.h"

#include "ncdrequestconfiguration.h"

#include "ncdrequestconfigurationdata.h"

#include "catalogssmsutils.h"

#include "catalogscontext.h"

#include "ncdkeyvaluemap.h"

#include "ncdutils.h"

#include "ncdstoragemanager.h"

#include "ncdproviderdefines.h"

#include "ncdstorage.h"

#include "ncdconfigurationmanager.h"

#include "ncdprotocoldefaultobserverimpl.h"

#include "catalogsutils.h"

#include "ncd_cp_cookieimpl.h"

#include "ncd_cp_detailimpl.h"

#include "ncdinternalconfigurationkeys.h"

#include "ncdcapabilities.h"

#include "ncdserverdetails.h"

#include "catalogsuids.h"

#include "ncdproviderutils.h"

#include "ncdengineconfiguration.h"

#include "ncdinstallationserviceimpl.h"

#include "ncdprotocolstrings.h"

#include "catalogs_device_config.h"

 // Hardcoded platforminfo

_LIT( KPlatformInfo, "Series60" );

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

// CContextData::CContextData

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

//

CNcdProtocol::CContextData::CContextData( const MCatalogsContext& aContext, 

    CNcdSessionHandler* aSessionHandler ) : CBase(),

        iFamilyId( aContext.FamilyId() ),                

        iSessionHandler( aSessionHandler )

    {

    }

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

// CContextData::~CContextData

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

//

CNcdProtocol::CContextData::~CContextData()

    {    

    delete iSessionHandler;

    }

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

// CContextData::SessionHandler

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

//

MNcdSessionHandler& CNcdProtocol::CContextData::SessionHandler() const

    {

    DASSERT( iSessionHandler );

    return *iSessionHandler;

    }

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

// CContextData::Context

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

//

TUid CNcdProtocol::CContextData::FamilyId() const

    {

    return iFamilyId;

    }

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

// CContextData::SessionL

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

//

void CNcdProtocol::CContextData::SessionL( const TDesC& aSessionId, 

    const TDesC& aServerUri, const TDesC& aNameSpace )

    {

    DLTRACEIN(( _L("Session Id: %S, server URI: %S, name space: %S"), 

        &aSessionId, &aServerUri, &aNameSpace ));            

    // Remove old session if any

    iSessionHandler->RemoveSession( aServerUri, aNameSpace );

    // Create a new session    

    DLTRACE( ( "Creating a new session" ) );      

    iSessionHandler->CreateSessionL( aServerUri, aNameSpace, aSessionId );

    DLTRACEOUT(( "" ));

    }

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

// Constructor

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

//

CNcdProtocol::CNcdProtocol( MNcdConfigurationManager& aConfigurationManager,

    CNcdSubscriptionManager& aSubscriptionManager ) : 

    iConfigurationManager( aConfigurationManager ),

    iSubscriptionManager( aSubscriptionManager )

    {

    }

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

// Destructor

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

//

CNcdProtocol::~CNcdProtocol()

    {

    DLTRACEIN((""));    

    delete iSmsUtils;

    iContexts.ResetAndDestroy();    

    DLTRACEOUT((""));

    }

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

// NewL

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

//

CNcdProtocol* CNcdProtocol::NewL( MNcdConfigurationManager& aConfigurationManager,

    CNcdSubscriptionManager& aSubscriptionManager )

    {

    CNcdProtocol* self = new(ELeave) CNcdProtocol( aConfigurationManager,

        aSubscriptionManager );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// ConstructL

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

//

void CNcdProtocol::ConstructL()

    {    

    DLTRACEIN((""));

    iSmsUtils = CCatalogsSmsUtils::NewL();

    iDeviceService = &CNcdProviderUtils::DeviceService();

    // This gets the firmware string and appends it with the variant

    // string

    iDeviceService->AppendVariantToFirmwareL( 

        CNcdProviderUtils::FileSession() );

    // Get home MCC and MNC so they don't have to be acquired separately

    // for every session

    iDeviceService->HomeNetworkInfoL( iHomeMcc, iHomeMnc );

    }

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

// CreateParserL

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

//

MNcdParser* CNcdProtocol::CreateParserL( MCatalogsContext& aContext,

    const TDesC& aServerUri )

    {    

    CContextData& data = CreateContextDataL( aContext );

    // Create default observer

    CNcdProtocolDefaultObserver* protocolDefaultObserver = 

        CNcdProtocolDefaultObserver::NewL( aContext,  

        iConfigurationManager,

        iSubscriptionManager,

        aServerUri );

    CleanupStack::PushL( protocolDefaultObserver );

    // Ownership of the default observer is transferred

    MNcdParser* parser = NcdParserFactory::CreateParserL( 

        protocolDefaultObserver );

    CleanupStack::Pop( protocolDefaultObserver );

    // Set all default observers here! Clients may override them.

    parser->Observers().SetSessionObserver( &data );

    CleanupDeletePushL( parser );

    // The following is used in session observer callback, 

    // and entityreference building:

    parser->SetOriginL( aServerUri );

    CleanupStack::Pop( parser );

    return parser;

    }

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

// Preminet protocol request processor

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

// 

HBufC8* CNcdProtocol::ProcessPreminetRequestL( 

    const MCatalogsContext& aContext, 

    CNcdRequestBase& aRequest, const TDesC& aServerUri,

    TBool aForceConfigurationData )

    {

    DLTRACEIN((""));

    // Get or create context data for the context

    CContextData& contextData( CreateContextDataL( aContext ) );

    HBufC* nameSpace = aRequest.NamespaceLC();

    TBool sessionExists = 

        contextData.SessionHandler().DoesSessionExist( aServerUri, *nameSpace );

    if ( aForceConfigurationData || !sessionExists ) 

        {

        DLTRACE(( _L("Session starts for server: %S, ns: %S"), &aServerUri,

            nameSpace ));

        CNcdRequestConfigurationData* config =

            CNcdRequestConfigurationData::NewLC();

        aRequest.SetConfigurationL( config );

        CleanupStack::Pop( config );

        // Common common processing for the request: add client-info etc.

        AddClientInfoToRequestL( aContext, *config );

        // Add engine's client-info

        AddEngineClientInfoToRequestL( *config );

        // Array for the cookies that are sent to the server

        RPointerArray<MNcdConfigurationProtocolCookie> cookies;

        CleanupResetAndDestroyPushL( cookies );

        // Add CGW cookies if there are any

        TBool cookiesChanged = AddCookiesL( 

            aContext, 

            cookies, 

            aServerUri,

            *nameSpace );

        // Add CDB cookies, these override existing server cookies        

        cookiesChanged |= AddCookiesL( 

            aContext,             

            cookies,             

            iConfigurationManager.MasterServerAddressL( aContext ),

            NcdProviderDefines::KConfigNamespace );

        // Finally add the cookies to the request        

        AddCookiesToRequestL( aRequest, cookies );

        CleanupStack::PopAndDestroy( &cookies );        

        // Remove expired cookies from db

        if ( cookiesChanged ) 

            {

            DLTRACE(("Cookies had expired, update the config to db"));

            iConfigurationManager.SaveConfigurationToDbL( aContext );

            }        

        }

    if ( sessionExists )    

        {        

        // Set session id for a continuing session

        aRequest.SetSessionL( contextData.SessionHandler().Session( 

            aServerUri, *nameSpace ) );

        }

    CleanupStack::PopAndDestroy( nameSpace );

    HBufC8* req = aRequest.CreateRequestL();

    DLINFO(("request=%S",req));

    DLTRACEOUT((""));

    return req;    

    }

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

// Configuration protocol request processor

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

// 

HBufC8* CNcdProtocol::ProcessConfigurationRequestL( 

    const MCatalogsContext& aContext, 

    CNcdRequestConfiguration& aRequest )

    {

    DLTRACEIN((""));

    // Get or create context data for the context

    CContextData& contextData( CreateContextDataL( aContext ) );

    CNcdRequestConfigurationData* config =

        CNcdRequestConfigurationData::NewLC();

    aRequest.SetConfigurationL( config );

    CleanupStack::Pop( config );

    // Common common processing for the request: add client-info etc.

    AddClientInfoToRequestL( aContext, *config );

    // Add engine's client-info

    AddEngineClientInfoToRequestL( *config );

    // Array for the cookies that are sent to the server

    RPointerArray<MNcdConfigurationProtocolCookie> cookies;

    CleanupResetAndDestroyPushL( cookies );

    // Add cookies if there any

    TBool cookiesChanged = AddCookiesL( aContext, 

        cookies,

        iConfigurationManager.MasterServerAddressL( aContext ),

        NcdProviderDefines::KConfigNamespace );

    AddCookiesToConfigRequestL( *config, cookies );

    CleanupStack::PopAndDestroy( &cookies );

    // Remove expired cookies from db

    if ( cookiesChanged ) 

        {

        DLTRACE(("Cookies had expired, update the config to db"));

        iConfigurationManager.SaveConfigurationToDbL( aContext );

        }

    HBufC8* req = aRequest.CreateRequestL();

    //DLINFO(("request=%S",req));

    DLTRACEOUT((""));

    return req;

    }

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

// Session handler getter

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

//

MNcdSessionHandler& CNcdProtocol::SessionHandlerL( 

    const MCatalogsContext& aContext ) const

    {

    TInt index = FindContextData( aContext );

    if ( index == KErrNotFound ) 

        {

        User::Leave( KErrNotFound );

        }

    return iContexts[index]->SessionHandler();

    }

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

// Protocol options setter

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

//

void CNcdProtocol::SetProtocolOptions( TUint32 aOptions )

    {

    DLTRACEIN(("aOptions: %d", aOptions ));

    iProtocolOptions = aOptions;

    }

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

// Add client-info to the request configuration

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

// 

void CNcdProtocol::AddClientInfoToRequestL( 

    const MCatalogsContext& aContext, 

    CNcdRequestConfigurationData& aConfig )

    {

    DLTRACEIN((""));

    // Connect to telephony services so it won't have to be done in each

    // deviceinteraction method that require such services

    iDeviceService->ConnectL();

    CNcdKeyValueMap *userConfig = NULL;

     // Search for the user configuration

    TRAPD( err, 

        userConfig = &iConfigurationManager.ConfigurationsL( aContext,

            MNcdUserConfiguration::ENcdConfigurationClientInfo ) );

    if ( err != KErrNone ) 

        {

        // @ Error handling!

        }

    RPointerArray<CNcdKeyValuePair> configPairs;

    // Using close since configPairs won't own the data it points to

    CleanupClosePushL( configPairs );

    if ( userConfig )

        {           

        configPairs.ReserveL( userConfig->Pairs().Count() );

        for ( TInt i = 0; i < userConfig->Pairs().Count(); ++i )

            {                

            configPairs.AppendL( userConfig->Pairs()[i] );

            }            

        }

    // Add network info to the request

    SetNetworkInfoL( aConfig );

    CNcdRequestConfigurationClient* client = 

        CNcdRequestConfigurationClient::NewLC();

    // Add hardware configuration info to the request

    SetHardwareConfigurationL( client->Hardware(), configPairs );

    // Add software configuration info to the request

    AddSoftwareConfigurationL( aContext, *client, configPairs );

    DLTRACE(("Add client-info to request"));

    aConfig.AddClientL( client );

    CleanupStack::Pop( client );

    CleanupStack::PopAndDestroy( &configPairs );

    // Close telephony services

    User::LeaveIfError( iDeviceService->Close() );    

    }

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

// AddEngineClientInfoToRequestL

// Adds a client info element describing the engine

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

//

void CNcdProtocol::AddEngineClientInfoToRequestL( 

    CNcdRequestConfigurationData& aConfig )

    {

    DLTRACEIN((""));

    // Create a new client-element

    CNcdRequestConfigurationClient* client = 

        CNcdRequestConfigurationClient::NewLC();

    // Create a new software element

    CNcdRequestConfigurationSoftware* software = 

        CNcdRequestConfigurationSoftware::NewLC();

    // Set type, version and UID    

    software->SetSoftwareTypeL( 

        CNcdProviderUtils::EngineConfig().EngineType() );

    software->SetSoftwareVersionL( 

        CNcdProviderUtils::EngineConfig().EngineVersion() );

    software->SetSoftwareIdsL( 

        CNcdProviderUtils::EngineConfig().EngineUid(), 

        KNullDesC, 

        KNullDesC8 );

    //Set provisioning for the engine     

    if ( CNcdProviderUtils::EngineConfig().EngineProvisioning().Length() ) 

        {

        CNcdConfigurationProtocolDetailImpl* detail =

            CreateDetailLC( NcdConfigurationKeys::KProvisioning, 

                CNcdProviderUtils::EngineConfig().EngineProvisioning() );

        software->AddSoftwareDetailsL( detail );

        CleanupStack::Pop( detail );        

        }

    // engine install drive

    CNcdConfigurationProtocolDetailImpl* drive =

        CreateDetailLC( NcdConfigurationKeys::KInstallDrive, 

            CNcdProviderUtils::EngineConfig().EngineInstallDrive() );

    software->AddSoftwareDetailsL( drive );

    CleanupStack::Pop( drive );        

    client->AddSoftwareL( software );

    CleanupStack::Pop( software );

    aConfig.AddClientL( client );

    CleanupStack::Pop( client );    

    }

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

// SetNetworkInfoL

// Fills the network information 

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

//

void CNcdProtocol::SetNetworkInfoL( CNcdRequestConfigurationData& aConfig )

    {

    DLTRACEIN(( "" ));

        {        

        DLTRACE(( "Setting MCC & MNC" ));

        // Get & set current MCC and MNC

        aConfig.SetNetworkMccL( iHomeMcc, iDeviceService->CurrentMccL() );

        aConfig.SetNetworkMncL( iHomeMnc, iDeviceService->CurrentMncL() );

        }

        // Set service provider name

        {        

        DLTRACE(( "Setting service provider name" ));

        TBuf<MNcdDeviceService::KServiceProviderMaxLength> spName;

        iDeviceService->ServiceProviderL( spName );

        DLINFO(( _L("SP: %S"), &spName ));

        aConfig.SetNetworkProviderL( spName );        

        }

     // IMSI not set on purpose     

     // Set SMS center number

     HBufC* smsc = iSmsUtils->SmsCenterNumberLC();

     aConfig.SetNetworkSmscL( *smsc );

     CleanupStack::PopAndDestroy( smsc );   

    /**

     * @ Add: gid1/2, msisdn, operatorname

     */