/*

* Copyright (c) 2004 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:  API implementation to manage NWSessionSlots.

*

*/

// INCLUDE FILES

#include <CPEngNWSessionSlotManager2.h>

#include "CPEngNWSessionSlotManager2Imp.h"

#include "CPEngNWSessionSlotID2.h"

#include "CPEngNWSessionSlotID2Imp.h"

#include "PEngStorageManager.h"

#include "CPEngSessionSlotState.h"

#include "CPEngSessionSlotId.h"

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

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

// CPEngNWSessionSlotManager2Imp::NewL()

// Two-phased constructor.

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

//

CPEngNWSessionSlotManager2Imp* CPEngNWSessionSlotManager2Imp::NewL(

    CPEngNWSessionSlotManager2& aInterface,

    TInt aPriority )

    {

    CPEngNWSessionSlotManager2Imp* self =

        new ( ELeave ) CPEngNWSessionSlotManager2Imp( aInterface, aPriority );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CPEngNWSessionSlotManager2Imp::~CPEngNWSessionSlotManager2Imp()

    {

#if _BullseyeCoverage

    cov_write();

#endif

    }

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

// CPEngNWSessionSlotManager2Imp::CPEngNWSessionSlotManager2Imp

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CPEngNWSessionSlotManager2Imp::CPEngNWSessionSlotManager2Imp( CPEngNWSessionSlotManager2& aInterface,

                                                              TInt aPriority )

        : iInterface( aInterface ),

        iCActivePriority( aPriority )

    {

    }

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

// CPEngNWSessionSlotManager2Imp::ConstructL()

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

//

void CPEngNWSessionSlotManager2Imp::ConstructL()

    {

    }

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

// CPEngNWSessionSlotManager2Imp::CreateNWSessionSlot()

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

//

TInt CPEngNWSessionSlotManager2Imp::CreateNWSessionSlot(

    const CPEngNWSessionSlotID2& aNWSessionSlotID )

    {

    const CPEngNWSessionSlotID2Imp* slotIDImp = aNWSessionSlotID.Implementation();

    if ( !slotIDImp->IsFullyDefined() )

        {

        return KErrArgument;

        }

    TRAPD( err, PEngStorageManager::CreateSessionFolderL( slotIDImp->BasePart(),

                                                          slotIDImp->AppId() ) );

    return err;

    }

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

// CPEngNWSessionSlotManager2Imp::RemoveNWSessionSlot()

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

//

TInt CPEngNWSessionSlotManager2Imp::RemoveNWSessionSlot(

    const CPEngNWSessionSlotID2& aNWSessionSlotID )

    {

    const CPEngNWSessionSlotID2Imp* slotIDImp = aNWSessionSlotID.Implementation();

    if ( !slotIDImp->IsFullyDefined() )

        {

        return KErrArgument;

        }

    TRAPD( err, PEngStorageManager::RemoveSessionFolderL( slotIDImp->BasePart(),

                                                          slotIDImp->AppId() ) );

    return err;

    }

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

// CPEngNWSessionSlotManager2Imp::GetNWSessionSlotsL()

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

//

void CPEngNWSessionSlotManager2Imp::GetNWSessionSlotsL(

    RPointerArray<CPEngNWSessionSlotID2>& aNWSessionSlotIDs,

    const CPEngNWSessionSlotID2* aMatchPattern,

    TPEngNWSessionSlotState* aMatchState ) const

    {

    //Get list of existing slot states

    RObjectArray< CPEngSessionSlotState > allSlots;

    CleanupClosePushL( allSlots );

    PEngStorageManager::AllSessionSlotsStatesL( allSlots );

    //Generate client side slotId's from existing and matching

    //NWSessionSlots

    TInt allSlotsCount = allSlots.Count();

    for ( TInt ix = 0; ix < allSlotsCount; ix++ )

        {

        const CPEngSessionSlotState* handledSlot = allSlots[ ix ];

        CPEngSessionSlotId& ssBaseId = handledSlot->SessionSlotId();

        const MDesC16Array& regApps = handledSlot->RegisteredApplications();

        const MDesC16Array& activeApps = handledSlot->ActiveApplications();

        DoGenerateMatchingSlotIdsL( aNWSessionSlotIDs,

                                    ssBaseId,

                                    regApps,

                                    activeApps,

                                    aMatchPattern,

                                    aMatchState );

        }

    CleanupStack::PopAndDestroy(); //slotStates

    }

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

// CPEngNWSessionSlotManager2Imp::ExistsNWSessionSlotL()

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

//

void CPEngNWSessionSlotManager2Imp::ExistsNWSessionSlotL(

    const CPEngNWSessionSlotID2& aNWSessionSlotID ) const

    {

    const CPEngNWSessionSlotID2Imp* slotIDImp = aNWSessionSlotID.Implementation();

    if ( !slotIDImp->IsFullyDefined() )

        {

        User::Leave( KErrArgument );

        }

    //Try get the wanted slot

    const CPEngSessionSlotId& wantedBaseId = aNWSessionSlotID.Implementation()->BasePart();

    CPEngSessionSlotState* wantedSlotState = CPEngSessionSlotState::NewLC();

    PEngStorageManager::SessionSlotStateL( wantedBaseId, *wantedSlotState );

    //Check if base & AppId's match to given match pattern

    TInt  matchStatus = KErrNotFound;

    if ( wantedSlotState->SessionSlotId().Match( wantedBaseId ) == KErrNone )

        {

        const MDesC16Array& apps = wantedSlotState->RegisteredApplications();

        TInt appsCount = apps.MdcaCount();

        for ( TInt ii = 0; ii < appsCount; ii++ )

            {

            TPtrC16 appId( apps.MdcaPoint( ii ) );

            matchStatus = aNWSessionSlotID.Implementation()->MatchAppIdPart( appId );

            if ( matchStatus == KErrNone )

                {

                break;

                }

            }

        }

    CleanupStack::PopAndDestroy( wantedSlotState );

    User::LeaveIfError( matchStatus );

    }

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

// IsIdMatch()

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

//

TBool IsIdMatch( const CPEngNWSessionSlotID2* aSlotIdMatcher,

                 const CPEngNWSessionSlotID2& aSlotId )

    {

    TBool idMatch = ETrue;

    if ( aSlotIdMatcher )

        {

        idMatch = ( aSlotId.MatchFullId( *aSlotIdMatcher ) == KErrNone );

        }

    return idMatch;

    }

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

// HasApp()

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

//

TBool HasApp( const MDesC16Array& aActiveApps, const TDesC& aAppId )

    {

    const TInt activeAppCount = aActiveApps.MdcaCount();

    for ( TInt ii = 0; ii < activeAppCount; ii++ )

        {

        TPtrC app = aActiveApps.MdcaPoint( ii );

        if ( app == aAppId )

            {

            return ETrue;

            }

        }

    return EFalse;

    }

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

// IsStateMatch()

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

//

TBool IsStateMatch( const TPEngNWSessionSlotState* aSlotStateMatcher,

                    const MDesC16Array& aActiveApps,

                    const CPEngNWSessionSlotID2& aSlotId )

    {

    TBool stateMatch = ETrue;

    if ( aSlotStateMatcher )

        {

        if ( *aSlotStateMatcher == EPEngNWPresenceSessionClosed )

            {

            //only closed apps wanted -> app id may not exist in aActiveApps

            stateMatch = !HasApp( aActiveApps, aSlotId.AppId() );

            }

        if ( *aSlotStateMatcher == EPEngNWPresenceSessionOpen )

            {

            //only open apps wanted -> app id must be found from aActiveApps

            stateMatch = HasApp( aActiveApps, aSlotId.AppId() );

            }

        }

    return stateMatch;

    }

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

// CPEngNWSessionSlotManager2Imp::DoGenerateMatchingSlotIdsL()

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

//

void CPEngNWSessionSlotManager2Imp::DoGenerateMatchingSlotIdsL(

    RPointerArray<CPEngNWSessionSlotID2>& aNWSessionSlotIDs,

    CPEngSessionSlotId& aSessionSlotBaseId,

    const MDesC16Array& aRegApps,

    const MDesC16Array& aActiveApps,

    const CPEngNWSessionSlotID2* aSlotIdMatcher,

    TPEngNWSessionSlotState* aSlotStateMatcher ) const

    {

    const TInt regAppCount = aRegApps.MdcaCount();

    for ( TInt ii = 0; ii < regAppCount; ii++ )

        {

        CPEngNWSessionSlotID2* slotId = CPEngNWSessionSlotID2::NewLC();

        CPEngNWSessionSlotID2Imp* slotIdImp = slotId->Implementation();

        slotIdImp->SetAllL( aSessionSlotBaseId,

                            aRegApps.MdcaPoint( ii ) );

        TBool idMatch = IsIdMatch( aSlotIdMatcher, *slotId );

        TBool stateMatch = IsStateMatch( aSlotStateMatcher, aActiveApps, *slotId );

        if ( idMatch && stateMatch )

            {

            User::LeaveIfError( aNWSessionSlotIDs.Append( slotId ) );

            CleanupStack::Pop( slotId );

            }

        else

            {

            CleanupStack::PopAndDestroy( slotId );

            }

        }

    }

// End of File