/*
* Copyright (c) 2005 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:  Presence attribute store proxy.
*
*/

//  INCLUDES
#include "CPEngPresenceAttrModelStorageProxy.h"
#include "CPEngPresenceAttrModel.h"
#include "CPEngModelStoreEntryAdapter.h"
#include "MPEngStorageManager.h"
#include "PEngAttributeStoreIDCodec.h"
#include "PEngWVPresenceAttributes2.h"
#include <E32Base.h>


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

// -----------------------------------------------------------------------------
// CPEngPresenceAttrModelStorageProxy::NewL()
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CPEngPresenceAttrModelStorageProxy* CPEngPresenceAttrModelStorageProxy::NewL(
    CPEngPresenceAttrModel& aAttributeModel )
    {
    CPEngPresenceAttrModelStorageProxy* self = new ( ELeave ) CPEngPresenceAttrModelStorageProxy(
        aAttributeModel );
    return self;
    }



// -----------------------------------------------------------------------------
// CPEngPresenceAttrModelStorageProxy::ConnectStorageL()
// -----------------------------------------------------------------------------
//
void CPEngPresenceAttrModelStorageProxy::ConnectStorageL( TBool aUserModel,
                                                          HBufC* aStoreId,
                                                          MPEngStorageManager& aStorageManager )

    {
    __ASSERT_ALWAYS( !iStoreEntry, User::Leave( KErrAlreadyExists ) );


    TPEngStorageType storageType = EPEngStorageBasicCached;
    if ( aUserModel )
        {
        storageType = EPEngStorageBasicPermanent;
        }


    iStoreEntry = CPEngModelStoreEntryAdapter::NewL( aStoreId,
                                                     aStorageManager,
                                                     storageType,
                                                     iAttributeModel );
    }


// -----------------------------------------------------------------------------
// CPEngPresenceAttrModelStorageProxy::CPEngPresenceAttrModelStorageProxy()
// -----------------------------------------------------------------------------
//
CPEngPresenceAttrModelStorageProxy::CPEngPresenceAttrModelStorageProxy(
    CPEngPresenceAttrModel& aAttributeModel )
        : iAttributeModel( aAttributeModel ),
        iEditLockOwned( EFalse ),
        iForceNotifySidChange( ETrue )
    {
    }


// -----------------------------------------------------------------------------
// CPEngPresenceAttrModelStorageProxy::~CPEngPresenceAttrModelStorageProxy()
// -----------------------------------------------------------------------------
//
CPEngPresenceAttrModelStorageProxy::~CPEngPresenceAttrModelStorageProxy()
    {
    StopEditSupport();
    }


// -----------------------------------------------------------------------------
// CPEngPresenceAttrModelStorageProxy::RetrieveFromStorageL()
// -----------------------------------------------------------------------------
//
TInt CPEngPresenceAttrModelStorageProxy::RetrieveFromStorageL()
    {
    //KErrArgument is used here because client is trying
    //perform storage operation for wrong kind of attribute model
    __ASSERT_ALWAYS( iStoreEntry, User::Leave( KErrArgument ) );

    return iStoreEntry->StorageManager().RetrieveL( *iStoreEntry );
    }


// -----------------------------------------------------------------------------
// CPEngPresenceAttrModelStorageProxy::StoreToStorageL()
// -----------------------------------------------------------------------------
//
void CPEngPresenceAttrModelStorageProxy::StoreToStorageL( TBool aForceStore ) const
    {
    __ASSERT_ALWAYS( iStoreEntry, User::Leave( KErrArgument ) );

    MPEngStorageManager& sm = iStoreEntry->StorageManager();
    if ( aForceStore )
        {
        //Updating the force notify flag from const storage method
        //is ok, because the value is internal storage advice,
        //and thus the data isn't directly visible to attribute clients
        CPEngPresenceAttrModelStorageProxy* nonConstSelf =
            const_cast<CPEngPresenceAttrModelStorageProxy*> ( this );

        //Force notification from SID change is sent if the storing fails
        //If storing succeds, no need to send SID change event "manually"
        nonConstSelf->iForceNotifySidChange = ETrue;
        sm.StoreExclusiveL( *iStoreEntry );
        nonConstSelf->iForceNotifySidChange = EFalse;
        }
    else
        {
        sm.StoreL( *iStoreEntry );
        }

    ForceSendAttrEventIfNeededL();
    }


// -----------------------------------------------------------------------------
// CPEngPresenceAttrModelStorageProxy::RemoveFromStorageL()
// -----------------------------------------------------------------------------
//
void CPEngPresenceAttrModelStorageProxy::RemoveFromStorageL()
    {
    __ASSERT_ALWAYS( iStoreEntry, User::Leave( KErrArgument ) );

    User::LeaveIfError( iStoreEntry->StorageManager().Delete( *iStoreEntry ) );
    }


// -----------------------------------------------------------------------------
// CPEngPresenceAttrModelStorageProxy::IsFromThisStorage()
// -----------------------------------------------------------------------------
//
TBool CPEngPresenceAttrModelStorageProxy::IsFromThisStorage(
    const MPEngStorageManager& aStorageManager ) const
    {
    if ( iStoreEntry &&
         ( &iStoreEntry->StorageManager() == &aStorageManager ) )
        {
        return ETrue;
        }


    return EFalse;
    }


// -----------------------------------------------------------------------------
// CPEngPresenceAttrModelStorageProxy::GainEditLockL()
// -----------------------------------------------------------------------------
//
void CPEngPresenceAttrModelStorageProxy::GainEditLockL( TBool aCreationAllowed )
    {
    __ASSERT_ALWAYS( iStoreEntry, User::Leave( KErrArgument ) );
    __ASSERT_ALWAYS( !iEditLockOwned, User::Leave( KErrLocked ) );

    if ( iStoreEntry->StorageManager().LockedL( *iStoreEntry ) )
        {
        User::Leave( KErrLocked );
        }

    User::LeaveIfError( iStoreEntry->Lock( EStorageLockLevelBasic,
                                           aCreationAllowed ) );
    iEditLockOwned = ETrue;
    }


// -----------------------------------------------------------------------------
// CPEngPresenceAttrModelStorageProxy::StopEditSupport()
// -----------------------------------------------------------------------------
//
TInt CPEngPresenceAttrModelStorageProxy::StopEditSupport()
    {
    TInt err = KErrNone;

    if ( iStoreEntry && iEditLockOwned )
        {
        iStoreEntry->Release();
        iEditLockOwned = EFalse;

        TRAP( err, ForceSendAttrEventIfNeededL() );
        }

    delete iStoreEntry;
    iStoreEntry = NULL;

    return err;
    }


// -----------------------------------------------------------------------------
// CPEngPresenceAttrModelStorageProxy::IsEditLocked()
// -----------------------------------------------------------------------------
//
TBool CPEngPresenceAttrModelStorageProxy::IsEditLocked() const
    {
    return iEditLockOwned;
    }


// -----------------------------------------------------------------------------
// CPEngPresenceAttrModelStorageProxy::ForceSendAttrEventIfNeededL()
// -----------------------------------------------------------------------------
//
void CPEngPresenceAttrModelStorageProxy::ForceSendAttrEventIfNeededL() const
    {
    if ( iForceNotifySidChange &&
         ( iAttributeModel.Type() != KUidPrAttrOnlineStatus ) )
        {
        HBufC* sid = PEngAttributeStoreIDCodec::GenerateStoreIdL( KUidPrAttrOnlineStatus,
                                                                  iAttributeModel.PresenceID() );
        CleanupStack::PushL( sid );
        MPEngStorageManager& m = iStoreEntry->StorageManager();
        User::LeaveIfError( m.NotifyChangedSId( *sid, iStoreEntry->StorageType() ) );
        CleanupStack::PopAndDestroy( sid );
        }
    }


// End of File