/*
* Copyright (c) 2007-2009 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:  Inline implementation
*
*/

#include <s32mem.h>
#include <mcallremotepartyinfo.h>

namespace RemotePartyMediatorApi 
    {
    enum TPanic
        {
        ENullPointer
        }; 
    _LIT( KRemotePartyMediatorApi, "RPMA");
    }

// ---------------------------------------------------------------------------
// static constructor
// ---------------------------------------------------------------------------
//
CCallRemotePartyInfo* CCallRemotePartyInfo::NewL()
    {
    CCallRemotePartyInfo* self = CCallRemotePartyInfo::NewLC();
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// static constructor
// ---------------------------------------------------------------------------
//
CCallRemotePartyInfo* CCallRemotePartyInfo::NewLC()
    {
    CCallRemotePartyInfo* self = new( ELeave )CCallRemotePartyInfo();
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CCallRemotePartyInfo::~CCallRemotePartyInfo()
    {
    delete iCompanyName;
    delete iMatchedName;
    delete iNameFromNetwork;
    delete iAddress;
    }

// ---------------------------------------------------------------------------
// Extarnalizes remote party info to stream
// ---------------------------------------------------------------------------
//
void CCallRemotePartyInfo::ExternalizeL( RWriteStream& aStream ) const
    {
    WriteDescriptorToStreamL( aStream, *iCompanyName );
    WriteDescriptorToStreamL( aStream, *iMatchedName );
    WriteDescriptorToStreamL( aStream, *iNameFromNetwork );
    WriteDescriptorToStreamL( aStream, *iAddress );
    aStream.WriteInt32L( iCallIndex );
    aStream.WriteInt32L( iRemoteIdentity );
    aStream.WriteInt32L( iSATCall );
    }

// ---------------------------------------------------------------------------
// Internalizes remote party info from stream
// ---------------------------------------------------------------------------
//
void CCallRemotePartyInfo::InternalizeL( RReadStream& aStream )
    {
    HBufC* companyName = ReadDescriptorFromStreamLC( aStream );
    HBufC* matchedName = ReadDescriptorFromStreamLC( aStream );
    HBufC* nameFromNetwork = ReadDescriptorFromStreamLC( aStream );    
    HBufC* address = ReadDescriptorFromStreamLC( aStream );    
    const TInt callIndex = aStream.ReadInt32L(); 
    const TInt remoteIdentity = aStream.ReadInt32L();
    const TInt SATCall = aStream.ReadInt32L();
    
    CleanupStack::Pop( 4, companyName ); 
    
    
    delete iCompanyName;
    delete iMatchedName;
    delete iNameFromNetwork;
    delete iAddress;
    
    
    iCompanyName = companyName;
    iMatchedName = matchedName;
    iNameFromNetwork = nameFromNetwork;
    iAddress = address;
    iCallIndex = callIndex;     
    iRemoteIdentity = static_cast < TRemoteIdentityStatus > ( remoteIdentity );
    iSATCall = SATCall;
    }

// ---------------------------------------------------------------------------
// Size of the descriptor required for the information to be externalized
// ---------------------------------------------------------------------------
//
TInt CCallRemotePartyInfo::Size() const
    {
    // each member descriptor also needs the length of the descriptor
    TInt size = sizeof(TInt) + iCompanyName->Size();    
    size += sizeof( TInt ) + iMatchedName->Size();
    size += sizeof( TInt ) + iNameFromNetwork->Size();
    size += sizeof( TInt ) + iAddress->Size();
    size += sizeof( TInt ); // Call index
    size += sizeof( TInt ); // remote identity    
    size += sizeof( TInt ); // SAT call
    return size;
    }
    
// ---------------------------------------------------------------------------
// Sets remote matched name
// ---------------------------------------------------------------------------
//
void CCallRemotePartyInfo::SetMatchedNameL( const TDesC& aName )
    {
    HBufC* name = aName.AllocL();
    delete iMatchedName;
    iMatchedName = name;
    }

// ---------------------------------------------------------------------------
// Sets remote name from network
// ---------------------------------------------------------------------------
//
void CCallRemotePartyInfo::SetNameFromNetworkL( const TDesC& aName )
    {
    HBufC* name = aName.AllocL();
    delete iNameFromNetwork;
    iNameFromNetwork = name;
    }

// ---------------------------------------------------------------------------
// Sets remote company name
// ---------------------------------------------------------------------------
//
void CCallRemotePartyInfo::SetCompanyNameL( const TDesC& aName )
    {
    HBufC* name = aName.AllocL();
    delete iCompanyName;
    iCompanyName = name;
    } 
    
    
// ---------------------------------------------------------------------------
// Sets remote address
// ---------------------------------------------------------------------------
//
void CCallRemotePartyInfo::SetAddressL( const TDesC& aAddress )
    {
    HBufC* address = aAddress.AllocL();
    delete iAddress;
    iAddress = address;
    }

// ---------------------------------------------------------------------------
// Sets call index
// ---------------------------------------------------------------------------
//
void CCallRemotePartyInfo::SetCallIndex( TInt aCallIndex ) 
    {
    iCallIndex = aCallIndex;
    }


// ---------------------------------------------------------------------------
// Sets remote identity
// ---------------------------------------------------------------------------
//
void CCallRemotePartyInfo::SetRemoteIdentity( TRemoteIdentityStatus aRemoteIdentity )
    {
    iRemoteIdentity = aRemoteIdentity;
    }

// ---------------------------------------------------------------------------
// Sets SAT call flag
// ---------------------------------------------------------------------------
//
void CCallRemotePartyInfo::SetSATCall( TBool aSatCall )
    {
    iSATCall = aSatCall;
    }
    
// ---------------------------------------------------------------------------
// From base class MCallRemotePartyInfo
// ---------------------------------------------------------------------------
//
const TDesC& CCallRemotePartyInfo::Address() const
    {
    return *iAddress;
    }

// ---------------------------------------------------------------------------
// From base class MCallRemotePartyInfo
// ---------------------------------------------------------------------------
//
const TDesC& CCallRemotePartyInfo::CompanyName() const
    {
    return *iCompanyName;
    }

// ---------------------------------------------------------------------------
// From base class MCallRemotePartyInfo
// ---------------------------------------------------------------------------
//
const TDesC& CCallRemotePartyInfo::MatchedName() const
    {
    return *iMatchedName;
    }

// ---------------------------------------------------------------------------
// From base class MCallRemotePartyInfo
// ---------------------------------------------------------------------------
//
const TDesC& CCallRemotePartyInfo::NameFromNetwork() const
    {
    return *iNameFromNetwork;
    }
    

// ---------------------------------------------------------------------------
// From base class MCallRemotePartyInfo
// ---------------------------------------------------------------------------
//
TInt CCallRemotePartyInfo::CallIndex() const
    {
    return iCallIndex;
    }


// ---------------------------------------------------------------------------
// From base class MCallRemotePartyInfo
// ---------------------------------------------------------------------------
//
MCallRemotePartyInfo::TRemoteIdentityStatus CCallRemotePartyInfo::RemoteIdentity() const
    {
    return iRemoteIdentity;
    }

// ---------------------------------------------------------------------------
// From base class MCallRemotePartyInfo
// ---------------------------------------------------------------------------
//
TBool CCallRemotePartyInfo::SATCall() const
    {
    return iSATCall;
    }




// ---------------------------------------------------------------------------
// From base class MCallRemotePartyInfo
// ---------------------------------------------------------------------------
//
TBool CCallRemotePartyInfo::operator==(const MCallRemotePartyInfo& aRemoteInfo) const
    {
        
    if ( iMatchedName->Match( aRemoteInfo.MatchedName() ) == KErrNone  &&  
         iNameFromNetwork->Match( aRemoteInfo.NameFromNetwork() ) == KErrNone  &&
         iCompanyName->Match( aRemoteInfo.CompanyName() ) == KErrNone  &&
         iAddress->Match( aRemoteInfo.Address() ) == KErrNone  && 
         iCallIndex == aRemoteInfo.CallIndex() &&
         iRemoteIdentity == aRemoteInfo.RemoteIdentity() &&
         iSATCall == aRemoteInfo.SATCall() )
        {
        return ETrue;
        }   
        
    return EFalse;
    }

// ---------------------------------------------------------------------------
// Reads descriptor from stream.
// ---------------------------------------------------------------------------
//
HBufC* CCallRemotePartyInfo::ReadDescriptorFromStreamLC( RReadStream& aStream )
    {
    const TInt descLength = aStream.ReadInt32L();
    HBufC* desc = HBufC::NewLC( descLength );
    TPtr descPtr = desc->Des();
    aStream.ReadL( descPtr, descLength );
    return desc;
    }

// ---------------------------------------------------------------------------
// writes descriptor to stream.
// ---------------------------------------------------------------------------
//
void CCallRemotePartyInfo::WriteDescriptorToStreamL( 
    RWriteStream& aStream,
    const TDesC& aDesc )
    {
    aStream.WriteInt32L( aDesc.Length() );
    aStream.WriteL( aDesc );
    }

// ---------------------------------------------------------------------------
// c++ constructor
// ---------------------------------------------------------------------------
//
CCallRemotePartyInfo::CCallRemotePartyInfo() : 
    iCallIndex( -1 ),
    iRemoteIdentity( MCallRemotePartyInfo::ERemoteIdentityUnknown )
    {
    }

// ---------------------------------------------------------------------------
// 2nd phase constructor
// ---------------------------------------------------------------------------
//
void CCallRemotePartyInfo::ConstructL()
    {
    iCompanyName = KNullDesC().AllocL();
    iMatchedName = KNullDesC().AllocL();
    iNameFromNetwork = KNullDesC().AllocL();        
    iAddress = KNullDesC().AllocL();    
    }
// ---------------------------------------------------------------------------
// static constructor
// ---------------------------------------------------------------------------
//
CCallRemotePartyInfos* CCallRemotePartyInfos::NewL()
    {
    CCallRemotePartyInfos* self = CCallRemotePartyInfos::NewLC();
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// static constructor
// ---------------------------------------------------------------------------
//
CCallRemotePartyInfos* CCallRemotePartyInfos::NewLC()
    {
    CCallRemotePartyInfos* self = new( ELeave )CCallRemotePartyInfos();
    CleanupStack::PushL( self );
    return self;
    }

// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CCallRemotePartyInfos::~CCallRemotePartyInfos()
    {
    iInfos.ResetAndDestroy();
    }

// ---------------------------------------------------------------------------
// Adds remote party information
// ---------------------------------------------------------------------------
//
void CCallRemotePartyInfos::AddL( CCallRemotePartyInfo* aInfo )
    {    
    __ASSERT_ALWAYS( aInfo, 
        User::Panic(RemotePartyMediatorApi::KRemotePartyMediatorApi, 
                    RemotePartyMediatorApi::ENullPointer ) );
    iInfos.AppendL( aInfo );
    }

// ---------------------------------------------------------------------------
// Remote party information access
// ---------------------------------------------------------------------------
//
const RPointerArray<CCallRemotePartyInfo>& 
    CCallRemotePartyInfos::RemotePartyInfos() const
    {
    return iInfos;
    }

// ---------------------------------------------------------------------------
// Packages remote party information to descriptor
// ---------------------------------------------------------------------------
//
HBufC8* CCallRemotePartyInfos::ExternalizeL() const
    {
    // Calculate the size of the descriptor required
    TInt sizeRequired = sizeof(TInt); // Count of the infos
    TInt count = iInfos.Count();
    for ( TInt i = 0; i < count; i++ )
        {
        sizeRequired += iInfos[i]->Size();
        }
    HBufC8* package = HBufC8::NewLC( sizeRequired );
    TPtr8 packagePtr = package->Des();
    RDesWriteStream stream( packagePtr );
    stream.PushL();
    stream.WriteInt32L( count );
    for( TInt i = 0; i < count; i++ )
        {
        iInfos[i]->ExternalizeL( stream );
        }
    stream.CommitL();
    stream.Pop();
    stream.Close();
    CleanupStack::Pop( package );
    return package;
    }

// ---------------------------------------------------------------------------
// Unpacks remote party informations from descriptor.
// ---------------------------------------------------------------------------
//
void CCallRemotePartyInfos::InternalizeL( const TDesC8& aData ) 
    {   
    iInfos.ResetAndDestroy();
    
    RDesReadStream stream( aData );
    stream.PushL();
    const TInt numberOfInfos = stream.ReadInt32L();
    for ( TInt i = 0; i < numberOfInfos; i++ )
        {
        CCallRemotePartyInfo* info = CCallRemotePartyInfo::NewLC();
        info->InternalizeL( stream );
        iInfos.AppendL( info );
        CleanupStack::Pop( info );
        }
    
    stream.Pop();
    stream.Close();      
    }

// ---------------------------------------------------------------------------
// c++ constructor
// ---------------------------------------------------------------------------
//
CCallRemotePartyInfos::CCallRemotePartyInfos()
    {
    
    }