/*

* 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:  NWSessionSlot notifier API implementation

*

*/

// INCLUDE FILES

#include "CPEngNWSessionSlotID2Imp.h"

#include "CPEngNWSessionSlotNotifier2Imp.h"

#include "CPEngNWSessionSlotEventEntry.h"

#include "GenObserverNotifyMediators.h"

#include "PEngStorageManager.h"

#include "MPEngStorageManagerWatcher.h"

#include "CPEngSessionSlotEvent.h"

#include "CPEngSessionSlotState.h"

#include "PresenceDebugPrint.h"

#include <CPEngNWSessionSlotID2.h>

#include <CPEngNWSessionSlotNotifier2.h>

#include <CPEngNWSessionSlotEvent2.h>

#include <MPEngNWSessionSlotObserver2.h>

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

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

// CPEngNWSessionSlotNotifier2Imp::NewL()

// Two-phased constructor.

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

//

CPEngNWSessionSlotNotifier2Imp* CPEngNWSessionSlotNotifier2Imp::NewL(

    CPEngNWSessionSlotNotifier2& aInterface,

    TInt aPriority )

    {

    CPEngNWSessionSlotNotifier2Imp* self =

        new ( ELeave ) CPEngNWSessionSlotNotifier2Imp( aInterface, aPriority );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CPEngNWSessionSlotNotifier2Imp::~CPEngNWSessionSlotNotifier2Imp()

    {

    iDying = ETrue;

    Stop();

    DeleteFilters();

    iObsArray.Close();

    delete iEventEntry;

    }

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

// CPEngNWSessionSlotNotifier2Imp::CPEngNWSessionSlotNotifier2Imp

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

// might leave.

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

//

CPEngNWSessionSlotNotifier2Imp::CPEngNWSessionSlotNotifier2Imp( CPEngNWSessionSlotNotifier2& aInterface,

                                                                TInt aPriority )

        : iInterface( aInterface ),

        iCActivePriority( aPriority )

    {

    }

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

// CPEngNWSessionSlotNotifier2Imp::ConstructL()

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

//

void CPEngNWSessionSlotNotifier2Imp::ConstructL()

    {

    iEventEntry = CPEngNWSessionSlotEvent2Copy::NewL();

    }

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

// CPEngNWSessionSlotNotifier2Imp::StartL()

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

//

void CPEngNWSessionSlotNotifier2Imp::StartL(

    const CPEngNWSessionSlotID2Imp* aSlotIdFilter,

    const TArray<TPEngNWSessionSlotEvent>* aEventFilter )

    {

    //Pre checks

    if ( iStarted )

        {

        User::Leave( KErrInUse );

        }

    //Clear possibly existing filters

    DeleteFilters();

    //And initialize new ones

    if ( aSlotIdFilter )

        {

        iSlotIdFilter = aSlotIdFilter->CloneL();

        }

    if ( aEventFilter )

        {

        const TInt eventsCount = aEventFilter->Count();

        if ( eventsCount == 0 )

            {

            User::Leave( KErrArgument );

            }

        iEventFilter = new ( ELeave ) RArray<TPEngNWSessionSlotEvent>;

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

            {

            iEventFilter->InsertInSignedKeyOrderL( ( *aEventFilter )[ ii ] );

            }

        }

    //Register for events

    PEngStorageManager::RegisterGlobalEventObserverL( *this );

    iStarted = ETrue;

    }

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

// CPEngNWSessionSlotNotifier2Imp::Stop()

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

//

void CPEngNWSessionSlotNotifier2Imp::Stop()

    {

    if ( !iStarted )

        {

        return;

        }

    PEngStorageManager::UnregisterGlobalObserver( *this );

    iStarted = EFalse;

    DeleteFilters();

    }

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

// CPEngNWSessionSlotNotifier2Imp::IsActive()

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

//

TBool CPEngNWSessionSlotNotifier2Imp::IsActive() const

    {

    return iStarted;

    }

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

// CPEngNWSessionSlotNotifier2Imp::PushNWSessionSlotStateToObservers()

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

//

TInt CPEngNWSessionSlotNotifier2Imp::PushNWSessionSlotStateToObservers(

    const CPEngNWSessionSlotID2& aMatchPattern )

    {

    if ( iSynchNotifyRunning || iObsArray.NotifyLoopRunning() )

        {

        return KErrInUse;

        }

    iSynchNotifyRunning = ETrue;

    TRAPD( err, DoNotifyNWSessionSlotStatesL( *aMatchPattern.Implementation() ) );

    iSynchNotifyRunning = EFalse;

    return err;

    }

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

// CPEngNWSessionSlotNotifier2Imp::GetNWSessionSlotState()

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

//

TInt CPEngNWSessionSlotNotifier2Imp::GetNWSessionSlotState(

    const CPEngNWSessionSlotID2& aNWSessionSlotID,

    TPEngNWSessionSlotState& aState ) const

    {

    TRAPD( err,

        {

        CPEngSessionSlotState* state = CPEngSessionSlotState::NewLC();

        PEngStorageManager::SessionSlotStateL( aNWSessionSlotID.Implementation()->BasePart(),

                                               *state );

        aState = state->AppState( aNWSessionSlotID.AppId() );

        CleanupStack::PopAndDestroy( state );

        } );

    return err;

    }

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

// CPEngNWSessionSlotNotifier2Imp::AddObserver()

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

//

TInt CPEngNWSessionSlotNotifier2Imp::AddObserver(

    MPEngNWSessionSlotObserver2& aObserver )

    {

    //Observer array takes care from possible NULL pointers

    return iObsArray.AddObserver( &aObserver );

    }

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

// CPEngNWSessionSlotNotifier2Imp::RemoveObserver()

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

//

TInt CPEngNWSessionSlotNotifier2Imp::RemoveObserver(

    MPEngNWSessionSlotObserver2& aObserver )

    {

    return iObsArray.RemoveObserver( &aObserver );

    }

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

// CPEngNWSessionSlotNotifier2Imp::HandleNewSessionSlotEventL()

// From MPEngGlobalEventObserver

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

//

void CPEngNWSessionSlotNotifier2Imp::HandleNewSessionSlotEventL(

    const CPEngSessionSlotEvent& aSessionEvent )

    {

    if ( iDying )

        {

        return;

        }

    iEventEntry->Implementation()->SetFullEventReferenceL( aSessionEvent );

    TBool eventAccepted = IsEventAccepted( iEventEntry->NWSessionSlotID(),

                                           iEventEntry->Event() );

    if ( eventAccepted )

        {

        MediateNotify( KErrNone, *iEventEntry );

        }

    iEventEntry->Implementation()->ResetReferences();

    }

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

// CPEngNWSessionSlotNotifier2Imp::HandleObserverError()

// From MPEngGlobalEventObserver

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

//

void CPEngNWSessionSlotNotifier2Imp::HandleObserverError( TInt aError )

    {

    if ( iDying )

        {

        return;

        }

    iEventEntry->Implementation()->ResetReferences();

    MediateNotify( aError, *iEventEntry );

    }

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

// CPEngNWSessionSlotNotifier2Imp::DoNotifyNWSessionSlotStatesL()

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

//

void CPEngNWSessionSlotNotifier2Imp::DoNotifyNWSessionSlotStatesL(

    const CPEngNWSessionSlotID2Imp& aSlotIdMatcher )

    {

    //this might be called during the event notify loop

    //==> use here temp objects so the original data isn't messed up

    RObjectArray< CPEngSessionSlotState > ssStates;

    CleanupClosePushL( ssStates );

    CPEngNWSessionSlotEvent2Copy* eventEntry = CPEngNWSessionSlotEvent2Copy::NewL();

    CleanupStack::PushL( eventEntry );

    //Get list of existing slot states

    PEngStorageManager::AllSessionSlotsStatesL( ssStates );

    TInt matchCount = 0;

    //Generate client side events from requested NWSessionSlots

    const TInt ssStatesCount = ssStates.Count();

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

        {

        const CPEngSessionSlotState& ssState = *ssStates[ ii ];

        CPEngSessionSlotId& ssBaseId = ssState.SessionSlotId();

        TBool baseMatch = ( aSlotIdMatcher.MatchBasePart( ssBaseId ) == KErrNone );

        if ( baseMatch )

            {

            const MDesC16Array& ssApplications = ssState.RegisteredApplications();

            const TInt appCount = ssApplications.MdcaCount();

            for ( TInt jj = 0; jj < appCount; jj++ )

                {

                TPtrC appId = ssApplications.MdcaPoint( jj );

                TBool appMatch = ( aSlotIdMatcher.MatchAppIdPart( appId ) == KErrNone );

                if ( appMatch )

                    {

                    matchCount++;

                    eventEntry->Implementation()->SetPseudoEventReferenceL(

                        ssBaseId,

                        appId,

                        ssState.AppState( appId ),

                        ssState.SessionSlotState() );

                    MediateNotify( KErrNone, *eventEntry );

                    eventEntry->Implementation()->ResetReferences();

                    }

                }

            }

        }

    if ( matchCount == 0 )

        {

        User::Leave( KErrNotFound );

        }

    CleanupStack::PopAndDestroy( 2 ); //ssStates, eventEntry

    }

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

// CPEngNWSessionSlotNotifier2Imp::DeleteFilters()

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

//

void CPEngNWSessionSlotNotifier2Imp::DeleteFilters()

    {

    delete iSlotIdFilter;

    iSlotIdFilter = NULL;

    if ( iEventFilter )

        {

        iEventFilter->Reset();

        }

    delete iEventFilter;

    iEventFilter = NULL;

    }

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

// CPEngNWSessionSlotNotifier2Imp::IsEventAccepted()

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

//

TBool CPEngNWSessionSlotNotifier2Imp::IsEventAccepted(

    const CPEngNWSessionSlotID2& aNWSessionSlotID,

    TPEngNWSessionSlotEvent aEvent ) const

    {

    TBool accepted = ETrue;

    if ( iSlotIdFilter )

        {

        if ( iSlotIdFilter->MatchFullId( *aNWSessionSlotID.Implementation() ) == KErrNotFound )

            {

            accepted = EFalse;

            }

        }

    if ( iEventFilter && accepted )

        {

        if ( iEventFilter->Find( aEvent ) == KErrNotFound )

            {

            accepted = EFalse;

            }

        }

    return accepted;

    }

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

// CPEngNWSessionSlotNotifier2Imp::MediateNotify()

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

//

void CPEngNWSessionSlotNotifier2Imp::MediateNotify( TInt aError,

                                                    CPEngNWSessionSlotEvent2& aEvent )

    {

    TGenNotifyMediator2 < MPEngNWSessionSlotObserver2,

    CPEngNWSessionSlotNotifier2&,

    CPEngNWSessionSlotEvent2& >

    eventMediator( &MPEngNWSessionSlotObserver2::HandleNWSessionSlotChangeL,

                   &MPEngNWSessionSlotObserver2::HandleNWSessionSlotError,

                   iInterface,

                   aEvent );

    if ( aError == KErrNone )

        {

        PENG_DP( D_PENG_LIT( "CPEngNWSessionSlotNotifier2 - Handle event: %d" ),

                 aEvent.Event() );

        iObsArray.NotifyObservers( eventMediator );

        }

    else

        {

        PENG_DP( D_PENG_LIT( "CPEngNWSessionSlotNotifier2 - Handle event error: %d" ),

                 aError );

        iObsArray.NotifyErrorObservers( eventMediator, aError );

        }

    }

// End of File