/*

* Copyright (c) 2005-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 <e32std.h>

#include <escapeutils.h>

#include <cmmanager.h>

#include <cmdestination.h>

#include <cmconnectionmethoddef.h>

#include <cmpluginwlandef.h>

#include "scpservicemanager.h"

#include "scpsettinghandler.h"

#include "scpservicestorage.h"

#include "scputility.h"

#include "scplogger.h"

#include "scpprofilehandler.h"

#include "scpservice.h"

#include "scpsubservice.h"

#include "scpsipconnection.h"

#include "scpstatecontainer.h"

const TInt KUsernameMaxLength = 255;

const TInt KDomainMaxLength = 255;

const TInt KTempBufMaxLength = 255;

#ifdef _DEBUG

const TInt KDebugInfoMaxLength = 255;

#endif

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

// CScpServiceManager::CScpServiceManager()

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

//

CScpServiceManager::CScpServiceManager( MCchServiceObserver& aServiceObserver ) :

    iServiceObserver( aServiceObserver )

    {

    SCPLOGSTRING( "CScpServiceManager::CScpServiceManager");

    }

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

// CScpServiceManager::NewL

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

//

CScpServiceManager* CScpServiceManager::NewL( MCchServiceObserver& aServiceObserver )

    {

    SCPLOGSTRING( "CScpServiceManager::NewL");

    CScpServiceManager* self = new ( ELeave ) CScpServiceManager( aServiceObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CScpServiceManager::ConstructL

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

//

void CScpServiceManager::ConstructL()

    {

    SCPLOGSTRING( "CScpServiceManager::ConstructL");

    iProfileHandler = CScpProfileHandler::NewL();

    iSettingHandler = CScpSettingHandler::NewL( *iProfileHandler );

    iServiceStorage = CScpServiceStorage::NewL( *iSettingHandler );  

    iStateContainer.InitializeL();

    }

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

// CScpServiceManager::~CScpServiceManager

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

//

CScpServiceManager::~CScpServiceManager()

    {    

    SCPLOGSTRING( "CScpServiceManager::~CScpServiceManager"); 

    delete iServiceStorage;

    delete iSettingHandler;

    delete iProfileHandler;

    }

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

// CScpServiceManager::GetServiceL

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

//

CScpService* CScpServiceManager::GetServiceL( TUint aServiceId,

                                              TCCHSubserviceType aSubServiceType )

    {

    SCPLOGSTRING2( "CScpServiceManager::GetService: %i", aServiceId );

    CScpService* service( NULL );

    if( iSettingHandler->ServiceExistsL( aServiceId ) )

        {

        service = iServiceStorage->GetServiceByServiceId( aServiceId );

        if( service )

            {

            TRAPD( result, iSettingHandler->UpdateSettingsL( *service, aSubServiceType ) );

            if( result != KErrNone )

                {

#ifndef SCP_UNIT_TEST

                __ASSERT_DEBUG( EFalse, User::Panic( KNullDesC, KErrGeneral ) );

#endif

                service = NULL;                    

                }

            if ( KErrNoMemory == result )

                {

                User::Leave( KErrNoMemory );

                }

            }

        }

    return service;

    }

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

// CScpServiceManager::CreateServiceL

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

//

CScpService* CScpServiceManager::CreateServiceL( TUint aServiceId,

                                                 TCCHSubserviceType aSubServiceType )

    {

    SCPLOGSTRING2( "CScpServiceManager::CreateServiceL: %i", aServiceId );

    if( !iSettingHandler->ServiceExistsL( aServiceId ) )

        {

        User::Leave( KErrNotFound );

        }

    // Check if it is already available

    CScpService* service = iServiceStorage->GetServiceByServiceId( aServiceId );

    if( !service )

        {

        CScpService& createdService = 

            iServiceStorage->CreateServiceL( aServiceId, 

                                             *iProfileHandler, 

                                             iServiceObserver );

        service = &createdService;

        TRAPD( result, iSettingHandler->UpdateSettingsL( *service, aSubServiceType ) );

        if( result != KErrNone )

            {

            // Remove the service if something went wrong

            iServiceStorage->RemoveService( service->Id() );

            User::Leave( result );

            }

        }

    else

        {

#ifndef SCP_UNIT_TEST

        __ASSERT_DEBUG( EFalse, User::Panic( KNullDesC, KErrAlreadyExists ) );

#endif

        }

    return service;

    }

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

// CScpServiceManager::EnableServiceL

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

//

void CScpServiceManager::EnableServiceL( TUint aServiceId,

                                         TCCHSubserviceType aSubServiceType )

    {

    SCPLOGSTRING2( "CScpServiceManager::EnableServiceL service:%i", aServiceId );

    SCPLOGSTRING2( "CScpServiceManager::EnableServiceL type:%i", aSubServiceType );

    __ASSERT_DEBUG( aServiceId > 0, User::Panic( KNullDesC, KErrNotFound ) );

    CheckRestrictedConnectionsL( aServiceId );

    CScpService* service = GetServiceL( aServiceId, aSubServiceType );

    if( !service )

        {

        service = CreateServiceL( aServiceId, aSubServiceType );

        }

    RArray< TInt > subServiceIds;

    CleanupClosePushL( subServiceIds );

    service->GetSubServiceIds( subServiceIds );

    for( TInt i=0 ;i<subServiceIds.Count(); i++ )

        {

        CScpSubService* subService = 

            service->GetSubService( subServiceIds[ i ] );

        if( subService )

            {

            SCPLOGSTRING2( "Subservice's type: %d", subService->SubServiceType() );

            // Check is VoIP supported

            if ( !iSettingHandler->IsVoIPSupported() && 

                 ECCHVoIPSub == subService->SubServiceType() )

                {

                SCPLOGSTRING( "No support for VoIP" );

                subService = NULL;

                }

            if ( subService && 

                 ( aSubServiceType == subService->SubServiceType() ||

                 ECCHUnknown == aSubServiceType ) )

                {

                UpdateProfileValuesL( aServiceId, aSubServiceType );                

                subService->EnableL();

                }

            }

        }

    CleanupStack::PopAndDestroy( &subServiceIds );                 

    SCPLOGSTRING( "CScpServiceManager::EnableServiceL out" );

    }

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

// CScpServiceManager::EnableServiceL

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

//

void CScpServiceManager::EnableServiceL( TUint aServiceId,

                                         TCCHSubserviceType aSubServiceType,

                                         TUint /*aIapId*/ )

    {

    // : Change sip profiles IAP settings, but

    // If SNAP != 0 add the IAP to SNAP (CommsDB)

    EnableServiceL( aServiceId, aSubServiceType );

    }

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

// CScpServiceManager::DisableServiceL

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

//

void CScpServiceManager::DisableServiceL( TUint aServiceId,

                                          TCCHSubserviceType aSubServiceType )

    {

    SCPLOGSTRING2( "CScpServiceManager::DisableService service:%i", aServiceId );

    __ASSERT_DEBUG( aServiceId > 0, User::Panic( KNullDesC, KErrNotFound ) );

    CScpService* service = GetServiceL( aServiceId, aSubServiceType );

    if( !service )

        {

        service = CreateServiceL( aServiceId, aSubServiceType );

        }

    RArray< TInt > subServiceIds;

    CleanupClosePushL( subServiceIds );

    service->GetSubServiceIds( subServiceIds );

    if( subServiceIds.Count() == 0 )

        {

        // Nothing to disable

        User::Leave( KErrNotFound );

        }

    TBool atLeastOneDisableSucceeded = EFalse; 

    for( TInt i=0 ;i<subServiceIds.Count(); i++ )

        {

        CScpSubService* subService = service->GetSubService( subServiceIds[ i ] );

        if( subService && ( aSubServiceType == subService->SubServiceType() ||

                            aSubServiceType == ECCHUnknown ) )

            {

            TInt result = subService->Disable(); 

            if( result == KErrNone )

                {

                atLeastOneDisableSucceeded = ETrue;

                }

            }

        }

    if( !atLeastOneDisableSucceeded )

        {

        User::Leave( KErrNotSupported );

        }

    CleanupStack::PopAndDestroy( &subServiceIds );

    // After the disabling there might be some cleaning to do

    iServiceStorage->RemoveDisabledServices();

    }

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

// CScpServiceManager::IsAvailableL

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

//

TBool CScpServiceManager::IsAvailableL( TUint /*aServiceId*/,

                                        TCCHSubserviceType /*a*/,

                                        const RArray<TUint32>& /*aIapIdArray*/ ) const

    {

    SCPLOGSTRING( "CScpServiceManager::IsAvailableL" );

    // :

    return ETrue;

    }

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

// CScpServiceManager::GetServiceState

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

//

TInt CScpServiceManager::GetServiceState( TUint aServiceId,

                                          TCCHSubserviceType aSubServiceType, 

                                          TCCHSubserviceState& aState ) const

    {

    SCPLOGSTRING2( "CScpServiceManager::GetServiceState service:%i", aServiceId );

    TInt result( KErrNone );

    aState = ECCHDisabled;

    CScpServiceManager* self = const_cast<CScpServiceManager*>(this);

    CScpService* service = NULL;

    TRAPD( err, service = self->GetServiceL( aServiceId, aSubServiceType ) );

    if ( KErrNoMemory == err )

        {

        return err;

        }

    if( service )

        {

        result = service->State( aSubServiceType, aState );

        }

    else

        {

        TRAP( result, service = CreateTemporaryServiceL( aServiceId, aSubServiceType ) );

        if( result == KErrNone && service )

            {

            result = service->State( aSubServiceType, aState );

            delete service;

            }

        }    

    return result;

    }

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

// CScpServiceManager::GetServiceNetworkInfo

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

//

TInt CScpServiceManager::GetServiceNetworkInfo( TUint aServiceId,

                                                TCCHSubserviceType aSubServiceType,

                                                TUint32& aSnapId, 

                                                TUint32& aIapId,

                                                TBool& aSnapLocked,

                                                TBool& aPasswordSet  ) const

    {

    SCPLOGSTRING( "CScpServiceManager::GetServiceNetworkInfo" );

    // Get service network info

    TRAPD( ret, GetServiceNetworkInfoL( aServiceId,

                                        aSubServiceType,

                                        aSnapId,

                                        aIapId,

                                        aSnapLocked,

                                        aPasswordSet) );

    return ret;

    }

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

// CScpServiceManager::SetSnapId

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

//

TInt CScpServiceManager::SetSnapId( TUint aServiceId,

                                    TCCHSubserviceType aSubServiceType,

                                    const TUint aSnapId )

    {

    SCPLOGSTRING4( "CScpServiceManager::SetSnapId service id: %d type: %d snap: %d",

                   aServiceId, aSubServiceType, aSnapId );

    return SetAccessPointId( aServiceId, aSubServiceType, EScpSnap, aSnapId );

    }

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

// CScpServiceManager::SetIapId

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

//

TInt CScpServiceManager::SetIapId( TUint aServiceId,

                                   TCCHSubserviceType aSubServiceType,

                                   TUint aIapId )

    {

    SCPLOGSTRING4( "CScpServiceManager::SetIapId service id: %d type: %d iap: %d",

                   aServiceId, aSubServiceType, aIapId );

    return SetAccessPointId( aServiceId, aSubServiceType, EScpIap, aIapId );

    }

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

// CScpServiceManager::SetAccessPointId

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

//

TInt CScpServiceManager::SetAccessPointId( TUint aServiceId,

                                           TCCHSubserviceType aSubServiceType, 

                                           TScpAccessPointType aAccessPointType, 

                                           TInt aAccessPointId )

    {

    SCPLOGSTRING4( "CScpServiceManager[0x%x]::SetAccessPointId: type: %d id: %d", 

                    this, aSubServiceType, aAccessPointId );

    TBool serviceCreated = EFalse;

    TInt result = KErrNone;

    CScpService* service = iServiceStorage->GetServiceByServiceId( aServiceId );

    if( !service )

        {

        TRAP( result, service = CreateTemporaryServiceL( aServiceId, 

                                                         ECCHUnknown ) );

        if( result == KErrNone )

            {

            serviceCreated = ETrue;

            }

        }

    if( result == KErrNone )

        {

        result = service->SetAccessPointId( aSubServiceType, 

                                            aAccessPointType, 

                                            aAccessPointId );

        }

    if( serviceCreated )

        {

        delete service;

        }

    return result;

    }

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

// CScpServiceManager::CreateTemporaryServiceL

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

//   

CScpService* CScpServiceManager::CreateTemporaryServiceL( TInt aServiceId,

                                                          TCCHSubserviceType aSubServiceType ) const

    {

    SCPLOGSTRING3( "CScpServiceManager::CreateTemporaryServiceL service id: %d type: %d", 

                    aServiceId,

                    aSubServiceType );

    // Create a temporary service

    CScpService* service = CScpService::NewL( aServiceId, 

                                              aSubServiceType, 

                                              *iProfileHandler,

                                              *iServiceStorage,  

                                              iServiceObserver );

    CleanupStack::PushL( service );

    service->SetServiceId( aServiceId );

    iSettingHandler->UpdateSettingsL( *service, aSubServiceType );

    CleanupStack::Pop( service );

    return service;

    }

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

// CScpServiceManager::GetServiceInfoL

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

//

void CScpServiceManager::GetServiceInfoL( TUint aServiceId,

                                          TCCHSubserviceType aSubServiceType,

                                          RBuf& aBuffer ) const

    {

    SCPLOGSTRING3( "CScpServiceManager::GetServiceInfoL service id: %d type: %d", 

                    aServiceId, aSubServiceType );  

// Info request about the state of SCP for debugging purposes

#ifdef _DEBUG

    TInt infoCode = 0xAAA;

    if( aServiceId == infoCode )

        {

        aBuffer.Close();

        HBufC* buf = HBufC::NewL( KDebugInfoMaxLength );

        TPtr ptr = buf->Des();

        iServiceStorage->GetDebugInfo( ptr );

        iProfileHandler->GetDebugInfo( ptr );

        aBuffer.Assign( buf );    

        return;

        }

#endif

    TBool sipConnectionCreated( EFalse );

    CScpSipConnection* sipConnection = GetSipConnectionL( aServiceId,

                                                          aSubServiceType, 

                                                          sipConnectionCreated );

    if( sipConnectionCreated )

        {

        CleanupStack::PushL( sipConnection );

        }

    TBuf8<KUsernameMaxLength> username;

    TBuf8<KDomainMaxLength> domain;

    TBuf16<KTempBufMaxLength> tempBuf;

    User::LeaveIfError( sipConnection->GetUsername( username ) );

    User::LeaveIfError( sipConnection->GetDomain( domain ) );

    _LIT16( KUsername, "username=");

    _LIT16( KDomain, "domain=");