/*
* Copyright (c) 2007 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:  CPresenceBuddyInfoImp object implementation.
*
*/


#include <s32buf.h>
#include <ximpidentity.h>
#include <presenceinfo.h>
#include <personpresenceinfo.h>

#include "ximpidentityimp.h"
#include "presencebuddyinfoimp.h"
#include "presenceinfoimp.h"
#include "personpresenceinfoimp.h"


// ---------------------------------------------------------------------------
// CPresenceBuddyInfoImp::NewLC()
// ---------------------------------------------------------------------------
//
EXPORT_C CPresenceBuddyInfoImp* CPresenceBuddyInfoImp::NewLC()
    {
    CPresenceBuddyInfoImp* self = new( ELeave ) CPresenceBuddyInfoImp;
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

// ---------------------------------------------------------------------------
// CPresenceBuddyInfoImp::NewL()
// ---------------------------------------------------------------------------
//
EXPORT_C CPresenceBuddyInfoImp* CPresenceBuddyInfoImp::NewL()
    {
    CPresenceBuddyInfoImp* self = NewLC();
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// CPresenceBuddyInfoImp::~CPresenceBuddyInfoImp()
// ---------------------------------------------------------------------------
//
CPresenceBuddyInfoImp::~CPresenceBuddyInfoImp()
    {
    if (iPresenceInfo)
        delete iPresenceInfo;
    if(iIdentity)
        delete iIdentity;
    }

// ---------------------------------------------------------------------------
// CPresenceBuddyInfoImp::CPresenceBuddyInfoImp()
// ---------------------------------------------------------------------------
//
CPresenceBuddyInfoImp::CPresenceBuddyInfoImp()
    {
    }

// ---------------------------------------------------------------------------
// CPresenceBuddyInfoImp::ConstructL()
// ---------------------------------------------------------------------------
//
void CPresenceBuddyInfoImp::ConstructL()
    {
    iPresenceInfo = CPresenceInfoImp::NewL();
    iIdentity = CXIMPIdentityImp::NewL();
    }

// ---------------------------------------------------------------------------
// CPresenceBuddyInfoImp::Set()
// ---------------------------------------------------------------------------
//
TInt CPresenceBuddyInfoImp::Set( MXIMPIdentity* aIdentity,
                                 MPresenceInfo* aPresenceInfo)
    {
    TInt err(KErrArgument);
    
    if(aIdentity && aPresenceInfo) // Check whether data is valid
        {
        delete iIdentity;
        iIdentity = TXIMPGetImpClassOrPanic< CXIMPIdentityImp >::From( *aIdentity );
        
        delete iPresenceInfo;
        iPresenceInfo = NULL;
        iPresenceInfo = 
            TXIMPGetImpClassOrPanic< CPresenceInfoImp >::From( *aPresenceInfo );
                
        err = KErrNone;
        }
    
    return err;
    }

// ---------------------------------------------------------------------------
// CPresenceBuddyInfoImp::SetPresenceInfo()
// ---------------------------------------------------------------------------
//
TInt CPresenceBuddyInfoImp::SetPresenceInfo(MPresenceInfo* aPresenceInfo)
    {
    TInt err(KErrArgument);
    if(aPresenceInfo)
        {
        delete iPresenceInfo;
        iPresenceInfo = NULL;
        iPresenceInfo = 
            TXIMPGetImpClassOrPanic< CPresenceInfoImp >::From( *aPresenceInfo );
        err = KErrNone;
        }
    
    return err;
    }

// ---------------------------------------------------------------------------
// CPresenceBuddyInfoImp::SetBuddyId()
// ---------------------------------------------------------------------------
//
TInt CPresenceBuddyInfoImp::SetBuddyId(MXIMPIdentity* aIdentity)
    {
    TInt err(KErrArgument);
    
    if(aIdentity)
        {
    delete iIdentity;
        iIdentity = TXIMPGetImpClassOrPanic< CXIMPIdentityImp >::From( *aIdentity );
    err = KErrNone;
        }
    
    return err;
    }

// ---------------------------------------------------------------------------
// CPresenceBuddyInfoImp::SetPersonPresenceL()
// ---------------------------------------------------------------------------
//
TInt CPresenceBuddyInfoImp::SetPersonPresenceL(
                        MPersonPresenceInfo* aPersonPresenceInfo)
    {
    TInt err(KErrArgument);
    if(aPersonPresenceInfo)
        {
        iPresenceInfo->SetPersonPresenceL(aPersonPresenceInfo);
        err = KErrNone;
        }
    
    return err;
    }

// ---------------------------------------------------------------------------
// CPresenceBuddyInfoImp::PresenceInfo()
// ---------------------------------------------------------------------------
//
const MPresenceInfo* CPresenceBuddyInfoImp::PresenceInfo() const
    {
    return iPresenceInfo;        
    }

// ---------------------------------------------------------------------------
// CPresenceBuddyInfoImp::BuddyUserId()
// ---------------------------------------------------------------------------
//
const MXIMPIdentity* CPresenceBuddyInfoImp::BuddyId() const
    {
    return iIdentity;        
    }
        
// ---------------------------------------------------------------------------
// CPresenceBuddyInfoImp::EqualsIdentity()
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CPresenceBuddyInfoImp::EqualsIdentity(
                            const MPresenceBuddyInfo* aOtherInstance ) const
    {
    TBool ret(EFalse);
    if(aOtherInstance)
        {
        const CXIMPIdentityImp* tmp = 
            TXIMPGetImpClassOrPanic< const CXIMPIdentityImp >::From( *(aOtherInstance->BuddyId()));
        ret = iIdentity->EqualsContent( *tmp);
        }
    return ret;
    }
    
// ---------------------------------------------------------------------------
// CPresenceBuddyInfoImp::NewFromStreamLC()
// ---------------------------------------------------------------------------
//
XIMPIMP_IMPLEMENT_DATAOBJ_NEWFROMSTREAM( CPresenceBuddyInfoImp )


// ---------------------------------------------------------------------------
// Implement supported interface access.
// ---------------------------------------------------------------------------
//
XIMPIMP_IF_BASE_GET_INTERFACE_BEGIN( CPresenceBuddyInfoImp, 
                                     MPresenceBuddyInfo )
XIMPIMP_IF_BASE_GET_INTERFACE_END()


XIMPIMP_IF_BASE_GET_CONST_INTERFACE_BEGIN( CPresenceBuddyInfoImp, 
                                           MPresenceBuddyInfo )
XIMPIMP_IF_BASE_GET_INTERFACE_END()

// ---------------------------------------------------------------------------
// CPresenceBuddyInfoImp::EqualsContent()
// ---------------------------------------------------------------------------
//
TBool CPresenceBuddyInfoImp::EqualsContent( 
    const CXIMPApiDataObjBase& aOtherInstance ) const
    {
    const CPresenceBuddyInfoImp* tmp =
        TXIMPGetImpClassOrPanic< const CPresenceBuddyInfoImp >::From( aOtherInstance.Base() );

    TBool same = ETrue;
    TBool x = iPresenceInfo->EqualsContent( *tmp->iPresenceInfo );
    same &= x;
    
    x = iIdentity->EqualsContent( *tmp->iIdentity );
    same &= x;
    
    return same;
    }
    
// ---------------------------------------------------------------------------
// CPresenceBuddyInfoImp::ExternalizeL()
// ---------------------------------------------------------------------------
//
EXPORT_C void CPresenceBuddyInfoImp::ExternalizeL( RWriteStream& aStream ) const
    {
    iPresenceInfo->ExternalizeL( aStream );
    iIdentity->ExternalizeL( aStream );
    }


// ---------------------------------------------------------------------------
// CPresenceBuddyInfoImp::InternalizeL()
// ---------------------------------------------------------------------------
//
EXPORT_C void CPresenceBuddyInfoImp::InternalizeL( RReadStream& aStream )
    {
    CPresenceInfoImp* tmp = CPresenceInfoImp::NewLC();
    tmp->InternalizeL( aStream );
    if (iPresenceInfo)
        delete iPresenceInfo;
    iPresenceInfo = NULL;
    iPresenceInfo = tmp;
    CleanupStack::Pop( tmp );
    
    CXIMPIdentityImp* tmp1 = CXIMPIdentityImp::NewLC();
    tmp1->InternalizeL( aStream );
    if (iIdentity)
        delete iIdentity;
    iIdentity = tmp1;
    CleanupStack::Pop( tmp1 );
    

    }