/*

* 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:   Implements CNcdProvider class

*

*/

// For streams

#include <s32mem.h>

// RFs

#include <f32file.h>

#include <bautils.h>

#include <es_sock.h> // KErrConnectionTerminated

#include <hash.h>

#include "ncdproviderimpl.h"

#include "catalogsbasemessage.h"

#include "catalogssession.h"

#include "ncdnodemanager.h"

#include "ncdfavoritemanagerimpl.h"

#include "ncdpurchasehistorydbimpl.h"

#include "ncdoperationmanager.h"

#include "ncdnodeimpl.h"

#include "ncdstoragemanagerimpl.h"

#include "ncdprotocolimpl.h"

#include "catalogsdebug.h"

#include "catalogsutils.h"

#include "catalogstransportimpl.h"

#include "catalogstransporttypes.h"

#include "ncdkeyvaluepair.h"

#include "ncdkeyvaluemap.h"

#include "ncdproviderdefines.h"

#include "ncdconfigurationmanagerimpl.h"

#include "ncdconfigurationkeys.h"

#include "catalogsuids.h"

#include "ncdutils.h"

#include "catalogscontext.h"

#include "catalogshttpsession.h"

#include "catalogssmssession.h"

#include "catalogshttpconfig.h"

#include "catalogsaccesspointmanagerimpl.h"

#include "ncdsubscriptionmanagerimpl.h"

#include "ncdpreviewmanager.h"

#include "ncdproviderutils.h"

#include "catalogsuids.h"

#include "ncdengineconfiguration.h"

#include "catalogsconstants.h"

#include "ncddatabaseversions.h"

#include "ncdsessionhandler.h"

#include "ncderrors.h"

#include "ncdreportmanager.h"

#include "ncdnodeseeninfo.h"

#include "ncdconnectionmethod.h"

#include "catalogsconnectionmethod.h"

#include "ncdhttputils.h"

#include "ncdserverreportmanagerimpl.h"

#include "ncdnodecachecleanermanager.h"

#include "ncdnodecachecleaner.h"

#include "ncdprovideroptions.h"

#include "ncdprovidercloseobserver.h"

#include "ncdgeneralmanager.h"

#ifdef __WINS__

// Fake SSID for emulator

_LIT8( KEmulatorFakeSsid, "emulatorssid" );

#endif 

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

// NewLC

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

//   

CNcdProvider* CNcdProvider::NewLC( 

    const TUid& aFamilyId,

    MNcdProviderCloseObserver& aCloseObserver,

    const TDesC& aEngineRoot,

    CCatalogsTransport& aTransport,

    CNcdStorageManager& aStorageManager )

    {

    CNcdProvider* self = new( ELeave ) CNcdProvider( 

        aFamilyId, 

        aCloseObserver,

        aEngineRoot,

        aTransport,

        aStorageManager );

    CleanupClosePushL( *self );

    self->ConstructL();

    return self;        

    }

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

// Destructor

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

//   

CNcdProvider::~CNcdProvider()

    {

    DLTRACEIN((""));

    iCloseObserver.ProviderClosed( *this );    

    if ( iServerReportManager )

        {

        iServerReportManager->Close();        

        }

    if ( iNodeManager ) 

        {

        iNodeManager->Close();

        }    

    if ( iPurchaseHistory )

        {

        iPurchaseHistory->Close();

        }

    if ( iOperationManager ) 

        {        

        iOperationManager->Close();

        }

    if ( iSubscriptionManager ) 

        {        

        iSubscriptionManager->Close();

        }

    if ( iFavoriteManager ) 

        {

        iFavoriteManager->Close();

        }

    delete iProtocolHandler;        

    delete iConfigurationManager;

    delete iHttpUtils;

    delete iAccessPointManager;    	

	TRAP_IGNORE( HandleShutdownFileL() );

	delete iGeneralManager;

	// Close provider's storage resources

	iStorageManager.CloseClient( FamilyName() );

    DLTRACEOUT((""));

    }

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

// ReceiveMessage

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

//       

void CNcdProvider::ReceiveMessage( MCatalogsBaseMessage* aMessage,

                                   TInt aFunctionNumber )

    {

    DLTRACEIN(("Function: %d", aFunctionNumber ));

    DASSERT( aMessage );

    TRAPD( trapError, ReceiveMessageL( *aMessage, aFunctionNumber) );    

    if ( trapError != KErrNone )

        {

        // Because something went wrong the complete has not been

        // yet called for the message.

        // So, inform the client about the error.

        aMessage->CompleteAndRelease( trapError );

        }

    }

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

// ReceiveMessageL

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

//       

void CNcdProvider::ReceiveMessageL( 

    MCatalogsBaseMessage& aMessage,

    TInt aFunctionNumber  )

    {

    switch( aFunctionNumber )

        {

        case ENcdProviderNodeManagerHandle:

            NodeManagerHandleRequestL( aMessage );

            break;

        case ENcdProviderPurchaseHistoryHandle:

            PurchaseHistoryHandleRequestL( aMessage );

            break;

        case ENcdProviderOperationManagerHandle:

            OperationManagerHandleRequestL( aMessage );

            break;

        case ENcdProviderSubscriptionManagerHandle:

            SubscriptionManagerHandleRequestL( aMessage );

            break;

        case ENcdProviderFavoriteManagerHandle:

            FavoriteManagerHandleRequestL( aMessage );

            break;

        case ENcdProviderServerReportManagerHandle:

            ServerReportManagerHandleRequestL( aMessage );

            break;

        case ENcdProviderRelease:

            ReleaseRequestL( aMessage );

            break;

        case ENcdProviderAddConfiguration:

            AddConfigurationRequestL( aMessage );

            break;

        case ENcdProviderRemoveConfiguration:

            RemoveConfigurationRequestL( aMessage );

            break;

        case ENcdProviderRetrieveConfigurations:

            RetrieveConfigurationsRequestL( aMessage );

            break;

        case ENcdProviderSetDefaultAccessPoint:

            SetDefaultAccessPointRequestL( aMessage );

            break;

        case ENcdProviderClientId:

            CreateClientIdRequestL( aMessage );

            break;

        case ENcdProviderClearCache:

            ClearCacheRequestL( aMessage );

            break;

        case ENcdGetProviderInfo:

            GetInfoRequestL( aMessage );

            break;

        case ENcdProviderIsSimChanged:

            IsSimChangedRequestL( aMessage );

            break;

        case ENcdProviderIsFixedAp:

            IsFixedApRequestL( aMessage );

            break;

        case ENcdProviderSyncSeenInfo:

            SyncSeenInfoRequestL( aMessage );

            break;

        default:

            User::Leave( KErrNotSupported );

            break;

        }

    }

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

// CounterPartLost

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

//       

void CNcdProvider::CounterPartLost( const MCatalogsSession& /* aSession */ )

    {

    /**

     * @ Implement this

     */

    }

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

// Handles connection confirmation requests

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

//           

TCatalogsHttpConnectionConfirmationState 

    CNcdProvider::HandleConnectionConfirmationRequestL( 

        MCatalogsHttpSession& /* aSession */, 

        const TCatalogsConnectionMethod& /* aMethod */  )

    {

    DLTRACEIN((""));

    /**

     * @ Handle connection confirmation requests

     */

    return ECatalogsHttpConnectionConfirmed;

    }

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

// Handles some errors in HTTP connections

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

//           

void CNcdProvider::HandleConnectionErrorL( 

    MCatalogsHttpSession& aSession,

    const TCatalogsConnectionMethod& /*aMethod*/, 

    TInt aError )

    {

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

    // Access point selection was cancelled so cancel all HTTP operations

    // Also connection termination by pressing the red phone button is handled

    // here

    if ( aError == KErrCancel ||

         aError == KErrConnectionTerminated )

        {

        aSession.NotifyCancelAllOperations();

        }

    }

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

// Constructor

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

//           

CNcdProvider::CNcdProvider( 

    const TUid& aFamilyId,

    MNcdProviderCloseObserver& aCloseObserver,

    const TDesC& aEngineRoot,

    CCatalogsTransport& aTransport,

    CNcdStorageManager& aStorageManager ) : 

        CCatalogsCommunicable(), 

        iFamilyId( aFamilyId ),

        iFamilyName( aFamilyId.Name() ),

        iCloseObserver( aCloseObserver ),

        iEngineRoot( aEngineRoot ),

        iStorageManager( aStorageManager ),

        iTransport( aTransport )

    {

    }

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

// ConstructL

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

//       

void CNcdProvider::ConstructL()

    {

    DLTRACEIN((""));

    RBuf familyPath;

    FamilyPathLC( familyPath );

    BaflUtils::EnsurePathExistsL( CNcdProviderUtils::FileSession(), familyPath );

    // Begin startup procedure. If the previous startup failed, all of 

    // provider's data files are deleted    

    // StartupEndL is called in PrepareSessionL

    TBool startupFailed = StartupBeginL( familyPath );    

    CleanupStack::PopAndDestroy( &familyPath );

    RBuf path;

    PurchaseHistoryPathLC( path );

    iPurchaseHistory = CNcdPurchaseHistoryDb::NewL( path );

    CleanupStack::PopAndDestroy( &path );

    DLTRACE(("iPurchaseHistory ok"));

    iGeneralManager = new( ELeave ) CNcdGeneralManager( 

        iFamilyId, 

        FamilyName() );

    iGeneralManager->SetStorageManager( iStorageManager );

    iGeneralManager->SetPurchaseHistory( *iPurchaseHistory );

    // Create configuration manager for the provider    

    iConfigurationManager = 

        CNcdConfigurationManager::NewL( *iGeneralManager );

    iGeneralManager->SetConfigurationManager( *iConfigurationManager );

    DLTRACE(("iConfigurationManager ok"));

    iNodeManager = CNcdNodeManager::NewL( *iGeneralManager );

    iGeneralManager->SetNodeManager( *iNodeManager );

    DLTRACE(("iNodeManager ok"));

    iAccessPointManager = 

        CCatalogsAccessPointManager::NewL( *iGeneralManager );

    iGeneralManager->SetAccessPointManager( *iAccessPointManager );

    DLTRACE(("iAccessPointManager ok"));    

    iSubscriptionManager = CNcdSubscriptionManager::NewL( 

        iStorageManager, *iNodeManager );

    iProtocolHandler = CNcdProtocol::NewL(

        *iConfigurationManager, *iSubscriptionManager );

    iGeneralManager->SetProtocolManager( *iProtocolHandler );

    DLTRACE(("iProtocolHandler ok"));

    iHttpUtils = new( ELeave ) CNcdHttpUtils( *iAccessPointManager );

    iGeneralManager->SetHttpUtils( *iHttpUtils );    

    iOperationManager = CNcdOperationManager::NewL( 

        *this, 

        *iGeneralManager,        

        *iSubscriptionManager );

    DLTRACE(("iOperationManager ok"));

    iSubscriptionManager->SetOperationManager( iOperationManager );

    DLTRACE(("iSubscriptionManager ok"));

    iFavoriteManager = CNcdFavoriteManager::NewL( *iGeneralManager );

    DLTRACE(("iFavoriteManager ok"));

    iNodeManager->SetFavoriteManager( *iFavoriteManager );

    iServerReportManager = CNcdServerReportManager::NewL( *this );

    DLTRACE(("iServerReportManager ok"));

    // If fixed AP must be used, set it to AP manager.    

    MNcdEngineConfiguration& engineConfig = CNcdProviderUtils::EngineConfig();

    if ( engineConfig.UseFixedAp() ) 

        {

        const RPointerArray<CNcdKeyValuePair>& apDetails = 

            engineConfig.FixedApDetails();

        TRAPD( err, iAccessPointManager->SetFixedApL( apDetails ) );

        if ( err != KErrNone ) 

            {

            User::Leave( KNcdErrorApCreationFailed );

            }

        }

    DLTRACEOUT((""));

    }

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

// NodeManagerHandleRequestL

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

//       

void CNcdProvider::NodeManagerHandleRequestL( 

    MCatalogsBaseMessage& aMessage ) const

    {

    // Get the session that will contain the handle

    MCatalogsSession& requestSession( aMessage.Session() );

    // Add the manager to the session and get the handle.

    TInt handle( requestSession.AddObjectL( iNodeManager ) );

    // Sent the information to the client side            

    aMessage.CompleteAndReleaseL( handle, KErrNone );    

    }

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

// PurchaseHistoryHandleRequestL

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

//       

void CNcdProvider::PurchaseHistoryHandleRequestL(

    MCatalogsBaseMessage& aMessage ) const

    {

    // Get the session that will contain the handle

    MCatalogsSession& requestSession( aMessage.Session() );

    // Add the purchase history to the session and get the handle.

    TInt handle( requestSession.AddObjectL( iPurchaseHistory ) );

    // Sent the information to the client side            

    aMessage.CompleteAndReleaseL( handle, KErrNone );        

    }

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

// OperationManagerHandleRequestL

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

//       

void CNcdProvider::OperationManagerHandleRequestL( 

    MCatalogsBaseMessage& aMessage ) const

    {

    // Get the session that will contain the handle

    MCatalogsSession& requestSession( aMessage.Session() );

    // Add the manager to the session and get the handle.

    TInt handle( requestSession.AddObjectL( iOperationManager ) );

    // Sent the information to the client side            

    aMessage.CompleteAndReleaseL( handle, KErrNone );        

    }

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

// SubscriptionManagerHandleRequestL

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

//       

void CNcdProvider::SubscriptionManagerHandleRequestL( 

    MCatalogsBaseMessage& aMessage ) const

    {

    // Get the session that will contain the handle

    MCatalogsSession& requestSession( aMessage.Session() );

    // Add the manager to the session and get the handle.

    TInt handle( requestSession.AddObjectL( iSubscriptionManager ) );

    // Sent the information to the client side            

    aMessage.CompleteAndReleaseL( handle, KErrNone );        

    }

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

// FavoriteManagerHandleRequestL

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

//       

void CNcdProvider::FavoriteManagerHandleRequestL( 

    MCatalogsBaseMessage& aMessage ) const

    {

    // Get the session that will contain the handle

    MCatalogsSession& requestSession( aMessage.Session() );

    // Add the manager to the session and get the handle.

    TInt handle( requestSession.AddObjectL( iFavoriteManager ) );

    // Sent the information to the client side            

    aMessage.CompleteAndReleaseL( handle, KErrNone );        

    }

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

// ServerReportHandleRequestL

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

//