/*
* Copyright (c) 2002 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:  It is used to liste Storage Ids and session state
*				 changes
*
*/



// INCLUDE FILES
#include    <e32std.h>
#include    "CPEngStorageManagerWatcher.h"

#include	"CPEngSessionSlotId.h"

#include	"CPEngSIdChangeListener.h"
#include	"MPEngStorageFactory.h"

#include	"PEngMessagePacker.h"
#include	"CPEngStorageManager.h"
#include	"MPEngGlobalEventObserver.h"

#include	"PresenceDebugPrint.h"




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

// -----------------------------------------------------------------------------
// CPEngStorageManagerWatcher::CPEngStorageManagerWatcher
// C++ default constructor can NOT contain any code, that might leave.
// -----------------------------------------------------------------------------
//
CPEngStorageManagerWatcher::CPEngStorageManagerWatcher(
    MPEngStorageFactory& aStorageFactory )
        : iStorageManagerFactory( aStorageFactory )
    {
    iAccessCount++;
    iStorageManagerFactory.OpenWatcher();
    }

// -----------------------------------------------------------------------------
// CPEngStorageManagerWatcher::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CPEngStorageManagerWatcher::ConstructL(
    const CPEngSessionSlotId& aSessionSlot,
    RPEngStorageClient& aStorageClient )
    {
    iSessionSlotId = aSessionSlot.CloneL();
    HBufC8* sessionName = aSessionSlot.PackLC();
    User::LeaveIfError( iNotifyClient.Connect( aStorageClient,
                                               *sessionName ) );
    CleanupStack::PopAndDestroy(); // sessionName
    }

// -----------------------------------------------------------------------------
// CPEngStorageManagerWatcher::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CPEngStorageManagerWatcher* CPEngStorageManagerWatcher::NewL(
    const CPEngSessionSlotId& aSessionSlot,
    RPEngStorageClient& aStorageClient,
    MPEngStorageFactory& aStorageFactory )
    {
    CPEngStorageManagerWatcher* self = NewLC(	aSessionSlot,
                                              aStorageClient,
                                              aStorageFactory );

    CleanupStack::Pop();

    return self;
    }

// -----------------------------------------------------------------------------
// CPEngStorageManagerWatcher::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CPEngStorageManagerWatcher* CPEngStorageManagerWatcher::NewLC(
    const CPEngSessionSlotId& aSessionSlot,
    RPEngStorageClient& aStorageClient,
    MPEngStorageFactory& aStorageFactory )
    {
    CPEngStorageManagerWatcher* self = new( ELeave )
    CPEngStorageManagerWatcher( aStorageFactory );
    // reference counted
    CleanupClosePushL( *self );
    self->ConstructL( aSessionSlot, aStorageClient );
    return self;
    }


// Destructor
CPEngStorageManagerWatcher::~CPEngStorageManagerWatcher()
    {
    // if we have not counter to zero, panic
    __ASSERT_ALWAYS( iAccessCount == 0,
                     User::Panic( KPEngSMEuserCBasePanic,
                                  KPEngSMEuserCBasePanicReason ) );

    // close has canceled all async requests
    delete iStorageIdListener;
    delete iSessionSlotId;
    iEventObservers.Reset();
    iNotifyClient.Close();

    iStorageManagerFactory.CloseStorageWatcher( this );
    // signal to the Storage factory that this Watcher is dying
    }



// =============================================================================
// =============== New public function of the class ============================
// =============================================================================

// -----------------------------------------------------------------------------
// CPEngStorageManagerWatcher::NotifyGlobalEvent()
// -----------------------------------------------------------------------------
//
void CPEngStorageManagerWatcher::NotifyGlobalEvent(
    const CPEngSessionSlotEvent& aNewEvent )
    {
    // notify observers
    TInt count ( iEventObservers.Count() );
    for ( TInt x( 0 ) ; x < count ; x++ )
        {
        TRAPD( e, iEventObservers[ x ]->HandleNewSessionSlotEventL(
                   aNewEvent ) );
        if ( e != KErrNone )
            {
            iEventObservers[ x ]->HandleObserverError( e );
            }
        }
    }


// -----------------------------------------------------------------------------
// CPEngStorageManagerWatcher::NotifySessionSlotRemovalL()
// -----------------------------------------------------------------------------
//
void CPEngStorageManagerWatcher::NotifyListenerError(
    TInt aError )
    {
    // notify observers
    TInt count ( iEventObservers.Count() );
    for ( TInt x( 0 ) ; x < count ; x++ )
        {
        iEventObservers[ x ]->HandleObserverError( aError );
        }
    }


// =============================================================================
// ============ Functions of the MPEngStorageManagerWatcher class===============
// =============================================================================

// -----------------------------------------------------------------------------
// CPEngStorageManagerWatcher::Open()
// -----------------------------------------------------------------------------
//
void CPEngStorageManagerWatcher::Open()
    {
    iAccessCount++;
    }


// -----------------------------------------------------------------------------
// CPEngStorageManagerWatcher::RegisterListenEventObserverL()
// -----------------------------------------------------------------------------
//
void CPEngStorageManagerWatcher::Close()
    {
    iAccessCount--;
    if ( iAccessCount == 0 ) // 0
        {
        delete this;
        }
    }


// -----------------------------------------------------------------------------
// CPEngStorageManagerWatcher::CreateStorageManagerL()
// -----------------------------------------------------------------------------
//
MPEngStorageManager* CPEngStorageManagerWatcher::CreateStorageManagerL()
    {
    return CPEngStorageManager::NewL(
               *this,
               iStorageManagerFactory.MainClient() );
    }


// -----------------------------------------------------------------------------
// CPEngStorageManagerWatcher::RegisterListenEventObserverL()
// -----------------------------------------------------------------------------
//
TPEngNWSessionSlotState CPEngStorageManagerWatcher::RegisterListenEventObserverL(
    MPEngGlobalEventObserver& aEventObserver )
    {
    User::LeaveIfError( iEventObservers.InsertInAddressOrder(
                            &aEventObserver ) );
    // increase reference counter
    this->Open();                       // CSI: 65 #

    return iSessionState;
    }


// -----------------------------------------------------------------------------
// CPEngStorageManagerWatcher::UnregisterListenEventObserver()
// -----------------------------------------------------------------------------
//
void CPEngStorageManagerWatcher::UnregisterListenEventObserver(
    MPEngGlobalEventObserver& aEventObserver )
    {
    TInt err ( iEventObservers.FindInAddressOrder( &aEventObserver ) );
    if ( err != KErrNotFound )
        {
        iEventObservers.Remove( err );
        this->Close();
        // decrease reference counter
        }
    }


// -----------------------------------------------------------------------------
// CPEngStorageManagerWatcher::CurrentStateOfPresenceServerL()
// -----------------------------------------------------------------------------
//
TPEngNWSessionSlotState CPEngStorageManagerWatcher::CurrentStateOfSessionSlot()
    {
    return iSessionState;
    }


// -----------------------------------------------------------------------------
// CPEngStorageManagerWatcher::RegisterListenSIDsObserverL()
// -----------------------------------------------------------------------------
//
void CPEngStorageManagerWatcher::RegisterListenSIDsObserverL(
    const MDesCArray& aInterestedSIds,
    MPEngSIDChangeObserver& aSIdChangeObserver,
    TPEngObserverPriority aPriority,
    TBool aKeepOldIds )
    {
    LoadSIdListenerL();
    // ETrue if listener was existing -> decrease ref count
    if ( iStorageIdListener->RegisterObserverL( aInterestedSIds,
                                                aSIdChangeObserver,
                                                aPriority,
                                                aKeepOldIds ) )
        {
        // increase reference counter
        this->Open();               // CSI: 65 #
        }
    }


// -----------------------------------------------------------------------------
// CPEngStorageManagerWatcher::RemoveSIDsFromSIDsObserverL()
// -----------------------------------------------------------------------------
//
void CPEngStorageManagerWatcher::RemoveSIDsFromSIDsObserver(
    const MDesCArray& aSIdsToRemove,
    const MPEngSIDChangeObserver& aSIdChangeObserver )
    {
    if ( iStorageIdListener )
        {
        iStorageIdListener->RemoveSIdsFromObserver(
            aSIdsToRemove,
            aSIdChangeObserver );
        }
    }

// -----------------------------------------------------------------------------
// CPEngStorageManagerWatcher::RestartSIDsObserver()
// -----------------------------------------------------------------------------
//
void CPEngStorageManagerWatcher::RestartSIDsObserver(
    const MPEngSIDChangeObserver& aSIdChangeObserver )
    {
    if ( iStorageIdListener )
        {
        iStorageIdListener->RestartObserver(
            aSIdChangeObserver );
        }
    }

// -----------------------------------------------------------------------------
// CPEngStorageManagerWatcher::UnregisterListenSIDsObserver()
// -----------------------------------------------------------------------------
//
void CPEngStorageManagerWatcher::UnregisterListenSIDsObserver(
    const MPEngSIDChangeObserver& aSIDChangeObserver )
    {
    if ( iStorageIdListener
         &&
         ( iStorageIdListener->UnRegisterObserver( aSIDChangeObserver ) )
       )
        {
        CleanStorageIdListener();
        this->Close();
        }
    }


// -----------------------------------------------------------------------------
// CPEngStorageManagerWatcher::SuspendListenSIDsObserver()
// -----------------------------------------------------------------------------
//
TInt CPEngStorageManagerWatcher::SuspendListenSIDsObserver(
    const MPEngSIDChangeObserver& aSIdChangeObserver )
    {
    if ( iStorageIdListener )
        {
        return iStorageIdListener->UpdateSuspendStateOfObserver(
                   aSIdChangeObserver,
                   ETrue );
        }
    return KErrNotFound;
    }


// -----------------------------------------------------------------------------
// CPEngStorageManagerWatcher::ResumeListenSIDsObserver()
// -----------------------------------------------------------------------------
//
TInt CPEngStorageManagerWatcher::ResumeListenSIDsObserver(
    const MPEngSIDChangeObserver& aSIdChangeObserver )
    {
    if (	iStorageIdListener )
        {
        return iStorageIdListener->UpdateSuspendStateOfObserver(
                   aSIdChangeObserver,
                   EFalse );
        }
    return KErrNotFound;
    }


// -----------------------------------------------------------------------------
// CPEngStorageManagerWatcher::SessionSlotId()
// -----------------------------------------------------------------------------
//
const CPEngSessionSlotId& CPEngStorageManagerWatcher::SessionSlotId() const
    {
    return *iSessionSlotId;
    }


// -----------------------------------------------------------------------------
// Private functions of the CPEngStorageManagerWatcher
// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------
// CPEngStorageManagerWatcher::CleanStorageIdListener()
// Check if there is still some SId listener
// and deletes it if it's not needed
// -----------------------------------------------------------------------------
//
void CPEngStorageManagerWatcher::CleanStorageIdListener()
    {
    if ( !iStorageIdListener->AnyActiveListener() )
        {
        delete iStorageIdListener;
        iStorageIdListener = NULL;
        }
    }

// -----------------------------------------------------------------------------
// CPEngStorageManagerWatcher::LoadSIdListenerL()
// Get Storage ID listener,
// if it does not exists, it constructed
// -----------------------------------------------------------------------------
//
void CPEngStorageManagerWatcher::LoadSIdListenerL()
    {
    if ( !iStorageIdListener )
        {
        iStorageIdListener = CPEngSIdChangeListener::NewL( iNotifyClient );
        }
    }


//  End of File