/*
* Copyright (c) 2008 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:  Store object for single buddy in a service
*
*/


#include <mpresencebuddyinfo2.h>

#include "presencecachebuddystore.h"
#include "presencecacheservicestore.h"
#include "presencecachesession.h"

// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::NewLC()
// ---------------------------------------------------------------------------
//
EXPORT_C CPresenceCacheBuddyStore* CPresenceCacheBuddyStore::NewLC(
                                    CPresenceCacheServiceStore* aServiceStore,
                                    const TDesC& aIdentity)
    {
    CPresenceCacheBuddyStore* self = new( ELeave ) CPresenceCacheBuddyStore(
                                            aServiceStore);
    CleanupStack::PushL( self );
    self->ConstructL(aIdentity);
    return self;
    }

// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::NewL()
// ---------------------------------------------------------------------------
//
EXPORT_C CPresenceCacheBuddyStore* CPresenceCacheBuddyStore::NewL(
                                    CPresenceCacheServiceStore* aServiceStore,
                                    const TDesC& aIdentity)
    {
    CPresenceCacheBuddyStore* self = NewLC(aServiceStore,aIdentity);
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::~CPresenceCacheBuddyStore()
// ---------------------------------------------------------------------------
//
CPresenceCacheBuddyStore::~CPresenceCacheBuddyStore()
    {
    if (iPresenceBuddyInfo)
        delete iPresenceBuddyInfo;
    if(iIdentity)
        delete iIdentity;
    iSubscribedSessions.Close();
    }

// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::CPresenceCacheBuddyStore()
// ---------------------------------------------------------------------------
//
CPresenceCacheBuddyStore::CPresenceCacheBuddyStore(
          CPresenceCacheServiceStore* aServiceStore):iPresenceBuddyInfo(NULL),
                                                    iServiceStore(aServiceStore)
    {
    }

// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::ConstructL()
// ---------------------------------------------------------------------------
//
void CPresenceCacheBuddyStore::ConstructL(const TDesC& aIdentity)
    {
    iIdentity = aIdentity.AllocL();
    }

// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::SetPresenceBuddyInfo()
// ---------------------------------------------------------------------------
//
void CPresenceCacheBuddyStore::SetPresenceBuddyInfo(MPresenceBuddyInfo2* aPresBuddyInfo)
    {
    delete iPresenceBuddyInfo;
    iPresenceBuddyInfo = aPresBuddyInfo;
    }

// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::RemovePresenceBuddyInfo()
// ---------------------------------------------------------------------------
//
void CPresenceCacheBuddyStore::RemovePresenceBuddyInfo()
    {
    if (iPresenceBuddyInfo)
        delete iPresenceBuddyInfo;
    iPresenceBuddyInfo = NULL;
    }

// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::GetSubscribedSessions()
// ---------------------------------------------------------------------------
//
RPointerArray<CPresenceCacheSession>& CPresenceCacheBuddyStore::GetSubscribedSessions()
    {
    return iSubscribedSessions;
    }

// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::AddSubscribedSession()
// ---------------------------------------------------------------------------
//
void CPresenceCacheBuddyStore::AddSubscribedSession(CPresenceCacheSession* aSession)
    {
    if(iSubscribedSessions.Find(aSession)<0)
        iSubscribedSessions.Append(aSession);
    }
    
// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::RemoveSubscribedSession()
// ---------------------------------------------------------------------------
//
void CPresenceCacheBuddyStore::RemoveSubscribedSession(CPresenceCacheSession* aSession)
    {
    TInt index = iSubscribedSessions.Find(aSession);
    if(index>-1)
        iSubscribedSessions.Remove(index);
    
    // delete this object if it doesnt have any presence or subscribers
    if(!(iPresenceBuddyInfo || HasSubscribers()))
        {
        if(iServiceStore)
            {
            iServiceStore->RemoveBlind(this);
            }
        }
    }

// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::SetBuddyId()
// ---------------------------------------------------------------------------
//
void CPresenceCacheBuddyStore::SetBuddyIdL(const TDesC& aIdentity)
    {
    delete iIdentity;
    iIdentity = NULL;
    iIdentity = aIdentity.AllocL();
    }

// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::ServiceName()
// ---------------------------------------------------------------------------
//
TPtrC CPresenceCacheBuddyStore::ServiceName() const
    {
    _LIT(KColon, ":");
    TInt pos = 0;
    if ( iIdentity )
        {
        pos = iIdentity->Des().Find(KColon);
        }
    TPtrC serviceName;
    if(pos>0) // if colon found and there is something before colon, i.e. xsp id
        {
        serviceName.Set( iIdentity->Des().Left(pos) );
        }
    else
        serviceName.Set(TPtrC());
    return serviceName;
    }
    
// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::PresenceBuddyInfo()
// ---------------------------------------------------------------------------
//
MPresenceBuddyInfo2* CPresenceCacheBuddyStore::PresenceBuddyInfo() const
    {
    return iPresenceBuddyInfo;
    }
    
// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::BuddyId()
// ---------------------------------------------------------------------------
//
TPtrC  CPresenceCacheBuddyStore::BuddyId() const
    {
    return iIdentity ? iIdentity->Des() : TPtrC();
    }

// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::EqualsIdentity()
// ---------------------------------------------------------------------------
//
TBool CPresenceCacheBuddyStore::EqualsIdentity(
                    const CPresenceCacheBuddyStore* aOtherInstance ) const
    {
    TBool ret(EFalse);
    if(aOtherInstance)
        {
        ret = 0 == BuddyId().CompareF( aOtherInstance->BuddyId() ); 
        }
    return ret;
    }
    
// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::EqualsIdentity()
// ---------------------------------------------------------------------------
//
TBool CPresenceCacheBuddyStore::EqualsIdentity(
                    const MPresenceBuddyInfo2* aOtherInstance ) const
    {
    TBool ret(EFalse);
    if(aOtherInstance)
        {
        ret = 0 == BuddyId().CompareF( aOtherInstance->BuddyId() );  
        }
    return ret;
    }
    
// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::EqualsIdentity()
// ---------------------------------------------------------------------------
//
TBool CPresenceCacheBuddyStore::EqualsIdentity(
                    const TDesC& aOtherIdentity ) const
    {
    return 0 == BuddyId().CompareF( aOtherIdentity );         
    }
    
// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::HasPresence()
// ---------------------------------------------------------------------------
//
TBool CPresenceCacheBuddyStore::HasPresence() const
    {
    if (iPresenceBuddyInfo)
        return ETrue;
    return EFalse;
    }

// ---------------------------------------------------------------------------
// CPresenceCacheBuddyStore::HasSubscribers()
// ---------------------------------------------------------------------------
//
TBool CPresenceCacheBuddyStore::HasSubscribers() const
    {
    if (iSubscribedSessions.Count())
        return ETrue;
    return EFalse;
    }