/*

* Copyright (c) 2002-2007 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:  Service storage class.

*

*/

#include "scpservicestorage.h"

#include "scplogger.h"

#include "scpservice.h"

#include "scpsubservice.h"

#include "scpsettinghandler.h"

const TInt KServiceIdCounterIncrement = 100;

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

// CScpServiceStorage::CScpServiceStorage

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

//

CScpServiceStorage::CScpServiceStorage( CScpSettingHandler& aSettingHandler ) : 

    iSettingHandler( aSettingHandler )

    {

    }

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

// CScpServiceStorage::NewL

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

//

CScpServiceStorage* CScpServiceStorage::NewL( CScpSettingHandler& aSettingHandler )

    {

    SCPLOGSTRING( "CScpServiceStorage::NewL" );

    CScpServiceStorage* self = new ( ELeave ) CScpServiceStorage( aSettingHandler );

    return self;

    }

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

// CScpServiceStorage::~CScpServiceStorage

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

//

CScpServiceStorage::~CScpServiceStorage()

    {

    SCPLOGSTRING( "CScpServiceStorage::~CScpServiceStorage" );

    iServiceItems.ResetAndDestroy();

    iServiceItems.Close();

    }

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

// CScpServiceStorage::CreateServiceL

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

//

CScpService& CScpServiceStorage::CreateServiceL( 

    TInt aServiceId, 

    CScpProfileHandler& aProfileHandler,

    MCchServiceObserver& aServiceObserver )

    {

    SCPLOGSTRING( "CScpServiceStorage::CreateServiceL" );

    CScpService* service( NULL );

    // Check that the service id does not already exist

    service = GetServiceByServiceId( aServiceId );

    if( service )

        {

        User::Leave( KErrAlreadyExists );

        }

    TInt newId = GenerateNewInternalIdForService();

    service = CScpService::NewL( newId, 

                                 aServiceId, 

                                 aProfileHandler,

                                 *this,

                                 aServiceObserver );

    CleanupStack::PushL( service );

    iServiceItems.AppendL( service );

    CleanupStack::Pop( service );

    CScpService* lastService = iServiceItems[ iServiceItems.Count() - 1 ];

    return *lastService;    

    }

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

// CScpServiceStorage::GenerateNewServiceId

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

//

TInt CScpServiceStorage::GenerateNewInternalIdForService()

    {

    SCPLOGSTRING( "CScpServiceStorage::GenerateNewInternalIdForService" );

    iServiceIdCounter += KServiceIdCounterIncrement;

    return iServiceIdCounter;

    }

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

// CScpServiceStorage::RemoveService

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

//

TInt CScpServiceStorage::RemoveService( TInt aId )

    {    

    SCPLOGSTRING2( "CScpServiceStorage::RemoveService id: %d", aId );

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

        {

        CScpService* service = iServiceItems[ i ];

        if( service && aId == service->Id() )

            {

            delete service;

            iServiceItems.Remove( i );

            return KErrNone;

            }

        }

    return KErrNotFound;      

    }

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

// CScpServiceStorage::RemoveDisabledServices

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

//

void CScpServiceStorage::RemoveDisabledServices()

    {

    SCPLOGSTRING( "CScpServiceStorage::RemoveEmptyServices" );

    RArray< TInt > subServiceIds;

    RArray< TInt > removedServiceIds;

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

        {

        CScpService* service = iServiceItems[ i ];

        if( service )

            {

            subServiceIds.Reset();

            service->GetSubServiceIds( subServiceIds );

            TBool remove( ETrue );

            // Remove if there are no sub services

            if( subServiceIds.Count() > 0 )

                {

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

                    {

                    CScpSubService* subService = 

                        service->GetSubService( subServiceIds[ j ] );

                    // Don't remove if there is at least one enabled or disconnecting

                    // sub service

                    if( subService && (

                            subService->EnableRequestedState() == CScpSubService::EScpEnabled ||

                            subService->State() == ECCHDisconnecting ) )

                        {

                        remove = EFalse;

                        }

                    else if ( subService )

                        {

                        service->RemoveSubService( subService->Id() );

                        }

                    }

                }

            if( remove ) 

                {

                removedServiceIds.Append( service->Id() ); 

                }

            }

        }

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

        {

        RemoveService( removedServiceIds[ i ] );

        }

    removedServiceIds.Close();

    subServiceIds.Close();

    }

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

// CScpServiceStorage::GetService

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

//

CScpService* CScpServiceStorage::GetService( TInt aId ) const

    {

    SCPLOGSTRING2( "CScpServiceStorage::GetService id: %d", aId );

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

        {

        CScpService* service = iServiceItems[ i ];

        if( aId == service->Id() )

            {

            return service;

            }

        }

    return NULL;    

    }

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

// CScpServiceStorage::GetServiceByServiceId

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

//

CScpService* CScpServiceStorage::GetServiceByServiceId( TUint aServiceId ) const

    {

    SCPLOGSTRING2( "CScpServiceStorage::GetServiceByServiceId id: %d", aServiceId );

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

        {

        CScpService* service = iServiceItems[ i ];

        if( aServiceId == service->ServiceId() )

            {

            return service;

            }

        }

    return NULL;

    }

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

// CScpServiceStorage::GetSubService

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

//

CScpSubService* CScpServiceStorage::GetSubService( TInt aId ) const

    {

    SCPLOGSTRING2( "CScpServiceStorage::GetSubService id: %d", aId );

    CScpSubService* returnSubService( NULL );

    RArray<TInt> subServiceIds;

    for( TInt i=0; i<iServiceItems.Count() && !returnSubService; i++)

        {

        CScpService* service = iServiceItems[ i ];

        subServiceIds.Reset();

        service->GetSubServiceIds( subServiceIds );

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

            {

            returnSubService = service->GetSubService( subServiceIds[ j ] );

            if( returnSubService )

                {

                if( returnSubService->Id() == aId )

                    {

                    break;

                    }

                else

                    {

                    returnSubService = NULL;

                    }

                }

            }

        }

    subServiceIds.Close();

    return returnSubService;

    }

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

// CScpServiceStorage::GetServiceIds

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

//

void CScpServiceStorage::GetServiceIds( RArray<TInt>& aIds ) const

    {

    SCPLOGSTRING( "CScpServiceStorage::GetServiceIds" );

    __ASSERT_DEBUG( aIds.Count() == 0, User::Panic( KNullDesC, KErrGeneral ) );

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

        {

        CScpService* service = iServiceItems[ i ];

        aIds.Append( service->Id() );

        }

    }

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

// CScpServiceStorage::GetSubServiceIds

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

//

void CScpServiceStorage::GetSubServiceIds( RArray<TInt>& aIds ) const

    {

    SCPLOGSTRING( "CScpServiceStorage::GetSubServiceIds" );

    __ASSERT_DEBUG( aIds.Count() == 0, User::Panic( KNullDesC, KErrGeneral ) );

    RArray<TInt> subServiceIds;

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

        {

        CScpService* service = iServiceItems[ i ];

        subServiceIds.Reset();

        service->GetSubServiceIds( subServiceIds );

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

            {

            aIds.Append( subServiceIds[ j ] );

            }

        }

    subServiceIds.Close();

    }

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

// CScpServiceStorage::GetSubServiceIds

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

//

void CScpServiceStorage::GetSubServiceIds( TCCHSubserviceType aSubServiceType,

                                           RArray<TInt>& aIds ) const

    {

    SCPLOGSTRING( "CScpServiceStorage::GetSubServiceIds" );

    __ASSERT_DEBUG( aIds.Count() == 0, User::Panic( KNullDesC, KErrGeneral ) );

    RArray< TInt > subServiceIds;

    GetSubServiceIds( subServiceIds );

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

        {

        CScpSubService* subService;

        subService = GetSubService( subServiceIds[ i ] );

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

            {

            aIds.Append( subService->Id() );

            }

        }

    subServiceIds.Close();

    }

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

// CScpServiceStorage::GetSubServiceIds

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

//

void CScpServiceStorage::GetSubServiceIds( TUint32 aProfileId,

                                           TCCHSubserviceType aSubServiceType,  

                                           RArray<TInt>& aIds ) const

    {

    SCPLOGSTRING3( "CScpServiceStorage::GetSubServiceIds profileId: %d type: %d",

                   aProfileId, aSubServiceType );

    __ASSERT_DEBUG( aIds.Count() == 0, User::Panic( KNullDesC, KErrGeneral ) );

    RArray< TInt > subServiceIds;

    GetSubServiceIds( subServiceIds );

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

        {

        CScpSubService* subService;

        subService = GetSubService( subServiceIds[ i ] );

        if( subService &&

            subService->SipProfileId() == aProfileId &&

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

            aSubServiceType == ECCHUnknown ) )

            {

            aIds.Append( subService->Id() );

            }

        }

    subServiceIds.Close();

    }

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

// CScpServiceStorage::IsSubServiceEnabled

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

//

TBool CScpServiceStorage::IsSubServiceEnabled( TUint32 aProfileId ) const

    {

    SCPLOGSTRING2( "CScpServiceStorage::IsSubServiceEnabled profile id: %d",

                   aProfileId );

    TBool result( EFalse );

    RArray< TInt > subServiceIds;

    GetSubServiceIds( aProfileId, ECCHUnknown, subServiceIds );

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

        {

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

        if( subService )

            {

            // Find at least one sub service that is still enabled

            if( subService->EnableRequestedState() == CScpSubService::EScpEnabled )

                {

                result = ETrue;

                break;

                }

            }

        }

    subServiceIds.Close();

    return result;

    }

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

// CScpServiceStorage::AreAllSubServicesDisconnected

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

//

TBool CScpServiceStorage::AreAllSubServicesDisconnected( TUint32 aProfileId ) const

    {

    SCPLOGSTRING2( "CScpServiceStorage::AreAllSubServicesDisconnected profile id: %d",

                   aProfileId );

    TBool result( ETrue );

    RArray< TInt > subServiceIds;

    GetSubServiceIds( aProfileId, ECCHUnknown, subServiceIds );

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

        {

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

        if( subService )

            {

            // Find at least one sub service that has been disabled but

            // it has not yet disconnected the service

            if( subService->EnableRequestedState() == CScpSubService::EScpDisabled &&

                subService->SubServiceDisconnected() == EFalse )

                {

                result = EFalse;

                break;

                }

            }

        }

    subServiceIds.Close();

    return result;

    }

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

// CScpServiceStorage::SettingsHandler

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

//

CScpSettingHandler& CScpServiceStorage::SettingsHandler()

    {

    SCPLOGSTRING( "CScpServiceStorage::SettingsHandler" );

    return iSettingHandler;

    }

#ifdef _DEBUG

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

// CScpServiceStorage::GetDebugInfo

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

//

void CScpServiceStorage::GetDebugInfo( TDes& aInfo ) const

    {

    TInt serviceCount = iServiceItems.Count();

    TInt subServiceCount( 0 );

    TInt enabledSubServices( 0 );

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

        {

        CScpService* service = iServiceItems[ i ];

        subServiceCount += service->SubServiceCount();

        RArray<TInt> subServiceIds;

        service->GetSubServiceIds( subServiceIds );

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

            {

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

            if( subService &&

                    subService->EnableRequestedState() == CScpSubService::EScpEnabled )

                {

                enabledSubServices++;

                }

            }

        subServiceIds.Close();

        }

    TBuf< 255 > buffer;

    buffer.Format( _L( "\nServices: %d\n SubServices: %d\n Enabled: %d\n" ),

                  serviceCount, subServiceCount, enabledSubServices ); 

    aInfo.Append( buffer );

    }

#endif

//  End of File