/*
* 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:  Implementation of contact data container
*
*/



// INCLUDE FILES
#include "CCAContact.h"
#include "CCAStorage.h"
#include "TCAStoragePanics.h"
#include "MCAStoredContactsObserver.h"
#include "MCAStorageInfo.h"
#include "TStorageManagerGlobals.h"
#include "ChatDebugPrint.h"
#include "CCAStorageDefs.h"
#include "CAUtils.h"

#include <e32base.h>
#include <e32std.h>
#include <e32def.h>
#include <s32strm.h>

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

// -----------------------------------------------------------------------------
// CCAContact::CCAContact
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CCAContact::CCAContact( MCAStoredContactsObserver* aObserver,
                        MCAStorageInfo* aVariation ) :
        iObserver( aObserver ), iVariation( aVariation )
    {
    iPresenceStatus = TStorageManagerGlobals::EUnknown;
    iClientType = TStorageManagerGlobals::EUnknownClient;
    }

// -----------------------------------------------------------------------------
// CCAContact::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CCAContact::ConstructL()
    {
    // creating empty user id to making sure that we always have some
    // initial "value", even though it is empty.
    // User id is necesssary information
    // for contact.
    iUserId = HBufC::NewL( 1 );

    // same for nickname
    iNickname = HBufC::NewL( 1 );

    // same for alias
    iAlias = HBufC::NewL( 1 );

    UpdateIdentification();
    }

// -----------------------------------------------------------------------------
// CCAContact::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CCAContact* CCAContact::NewL( MCAStoredContactsObserver* aObserver,
                              MCAStorageInfo* aVariation )
    {
    CCAContact* self = new( ELeave ) CCAContact( aObserver, aVariation );

    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );

    return self;
    }


// Destructor
CCAContact::~CCAContact()
    {
    delete iUserId;
    delete iNickname;
    delete iAlias;
    delete iStatusText;
    }

// -----------------------------------------------------------------------------
// CCAContact::UserId
// From MCAStoredContact
// -----------------------------------------------------------------------------
//
const TDesC& CCAContact::UserId() const
    {
    __ASSERT_ALWAYS( iUserId, Panic( ENoSuitableUserId ) );
    return *( iUserId );
    }

// -----------------------------------------------------------------------------
// CCAContact::Nickname
// From MCAStoredContact
// -----------------------------------------------------------------------------
//
const TDesC& CCAContact::Nickname() const
    {
    if ( iNickname )
        {
        return *iNickname;
        }
    return KNullDesC;
    }

// -----------------------------------------------------------------------------
// CCAContact::Alias
// From MCAStoredContact
// -----------------------------------------------------------------------------
//
const TDesC& CCAContact::Alias() const
    {
    if ( iAlias )
        {
        return *iAlias;
        }
    return KNullDesC;
    }

// -----------------------------------------------------------------------------
// CCAContact::Identification
// From MCAStoredContact
// -----------------------------------------------------------------------------
//
const TDesC& CCAContact::Identification() const
    {
    return iIdentification;
    }

// -----------------------------------------------------------------------------
// CCAContact::OnlineStatus
// From MCAStoredContact
// -----------------------------------------------------------------------------
//
TStorageManagerGlobals::TPresenceStatus CCAContact::OnlineStatus() const
    {
    return iPresenceStatus;
    }

// -----------------------------------------------------------------------------
// CCAContact::IsBlocked
// From MCAStoredContact
// -----------------------------------------------------------------------------
//
TBool CCAContact::IsBlocked() const
    {
    return iIsBlocked;
    }

// -----------------------------------------------------------------------------
// CCAContact::IsWatched
// From MCAStoredContact
// -----------------------------------------------------------------------------
//
TBool CCAContact::IsWatched() const
    {
    return iWatcherActive;
    }

// -----------------------------------------------------------------------------
// CCAContact::ClientType
// From MCAStoredContact
// -----------------------------------------------------------------------------
//
TStorageManagerGlobals::TClientType CCAContact::ClientType() const
    {
    return iClientType;
    }

// -----------------------------------------------------------------------------
// CCAContact::SetClientType
// From MCAStoredContact
// -----------------------------------------------------------------------------
//
void CCAContact::SetClientType( TStorageManagerGlobals::TClientType aType )
    {
    if ( iClientType != aType )
        {
        // state different, has changed
        iIsChanged |= 1;
        }

    iClientType = aType;
    }

// -----------------------------------------------------------------------------
// CCAContact::SetOnlineStatus
// From MCAStoredContact
// -----------------------------------------------------------------------------
//
void CCAContact::SetOnlineStatus(
    TStorageManagerGlobals::TPresenceStatus aOnlineStatus )
    {
    if ( iPresenceStatus != aOnlineStatus )
        {
        // state different, has changed
        iIsChanged |= 1;
        }

    iPresenceStatus = aOnlineStatus;
    }

// -----------------------------------------------------------------------------
// CCAContact::SetBlocked
// From MCAStoredContact
// -----------------------------------------------------------------------------
//
void CCAContact::SetBlocked( TBool aBlocked )
    {
    if ( iIsBlocked != aBlocked )
        {
        // state different, has changed
        iIsChanged |= 1;
        }

    iIsBlocked = aBlocked;
    }

// -----------------------------------------------------------------------------
// CCAContact::SetWatched
// From MCAStoredContact
// -----------------------------------------------------------------------------
//
void CCAContact::SetWatched( TBool aWatched )
    {
    if ( iWatcherActive != aWatched )
        {
        // state different, has changed
        iIsChanged |= 1;
        }

    iWatcherActive = aWatched;
    }

// -----------------------------------------------------------------------------
// CCAContact::SetPendingMessages
// From MCAExtendedStoredContact
// -----------------------------------------------------------------------------
//
void CCAContact::SetPendingMessages( TInt aAmount )
    {
    if ( iPendingMessages != aAmount )
        {
        // state different, has changed
        iIsChanged |= 1;
        }

    iPendingMessages = aAmount;
    }


// -----------------------------------------------------------------------------
// CCAContact::SignalChanges
// From MCAStoredContact
// -----------------------------------------------------------------------------
//
void CCAContact::SignalChanges()
    {
    TBool wasChanged( 0 != iIsChanged );
    iIsChanged = 0;

    if ( wasChanged )
        {
        // The observer shall decide whether to pass the information onward.
        iObserver->HandleChange( NULL, this,
                                 TStorageManagerGlobals::EStorageEventPostChange, iUserIdChanged );
        }

    iUserIdChanged = EFalse;
    }

// -----------------------------------------------------------------------------
// CCAContact::Selected
// From MCAStoredContact
// -----------------------------------------------------------------------------
//
TBool CCAContact::Selected() const
    {
    return iSelected;
    }

// -----------------------------------------------------------------------------
// CCAContact::SetSelected
// From MCAStoredContact
// -----------------------------------------------------------------------------
//
void CCAContact::SetSelected( TBool aSelected )
    {
    iSelected = aSelected;
    }

// -----------------------------------------------------------------------------
// CCAContact::SetSelected
// From MCAStoredContact
// -----------------------------------------------------------------------------
//
TInt CCAContact::PendingMessages() const
    {
    return iPendingMessages;
    }

// -----------------------------------------------------------------------------
// CCAContact::StatusText
// From MCAStoredContact
// -----------------------------------------------------------------------------
//
const TDesC& CCAContact::StatusText() const
    {
    if ( iStatusText )
        {
        return *iStatusText;
        }
    return KNullDesC;
    }

// -----------------------------------------------------------------------------
// CCAContact::SetStatusTextL
// From MCAStoredContact
// -----------------------------------------------------------------------------
//
void CCAContact::SetStatusTextL( const TDesC& aStatusText )
    {
    HBufC* tmp = aStatusText.AllocL();
    delete iStatusText;
    iStatusText = tmp;
    }

// -----------------------------------------------------------------------------
// CCAContact::GetPropertyL
// From MCAStoredContact
// -----------------------------------------------------------------------------
//
HBufC* CCAContact::PropertyL(
    TStorageManagerGlobals::TCAStorageProperty aProperty )
    {
    switch ( aProperty )
        {
        case TStorageManagerGlobals::EStoragePropNickname :
            {
            return iNickname->AllocL();
            // break;  // RVCT
            }
        case TStorageManagerGlobals::EStoragePropAlias :
            {
            return iAlias->AllocL();
            // break;  // RVCT
            }
        default :
            {
            return NULL;
            }
        }
    }

// -----------------------------------------------------------------------------
// CCAContact::GetPropertyL
// From MCAStoredContact
// -----------------------------------------------------------------------------
//
void CCAContact::SetPropertyL(
    TStorageManagerGlobals::TCAStorageProperty aProperty,
    const TDesC& aData )
    {
    switch ( aProperty )
        {
        case TStorageManagerGlobals::EStoragePropNickname :
            {
            // set nickname
            HBufC* tmp = aData.AllocL();
            delete iNickname;
            iNickname = tmp;

            UpdateIdentification();
            break;
            }
        case TStorageManagerGlobals::EStoragePropAlias :
            {
            HBufC* tmp = aData.AllocL();
            delete iAlias;
            iAlias = tmp;

            UpdateIdentification();
            break;
            }
        case TStorageManagerGlobals::EStoragePropUserId:
            {
            SetUserIdL( aData );
            break;
            }
        default :
            {
            // no such property
            User::Leave( KErrArgument );
            break;
            }
        }
    }

// -----------------------------------------------------------------------------
// CCAContact::UpdateIdentification
// Update identification of contact
// -----------------------------------------------------------------------------
//
void CCAContact::UpdateIdentification()
    {
    iIsChanged |= 1;

    if ( iVariation && iVariation->ShowNickname()
         && ( iNickname->Length() > 0 ) )
        {
        // use nickname as identification
        iIdentification.Set( *iNickname );
        return;
        }

    // no nickname
    if ( iAlias->Length() > 0 )
        {
        // use alias as identification from now on
        iIdentification.Set( *iAlias );
        return;
        }

    // otherwise always fallback to userid
    iIdentification.Set( CAUtils::DisplayId( *iUserId ) );
    }

// -----------------------------------------------------------------------------
// CCAContact::SetUserIdL
// From MCAExtendedStoredContact
// -----------------------------------------------------------------------------
//
void CCAContact::SetUserIdL( const TDesC& aUserId )
    {
    HBufC* tempUserId = aUserId.AllocL();
    delete iUserId;
    iUserId = tempUserId;
    iUserIdChanged = ETrue;

    UpdateIdentification();
    }

// -----------------------------------------------------------------------------
// CCAContact::SetNickname
// From MCAExtendedStoredContact
// -----------------------------------------------------------------------------
//
void CCAContact::SetNicknameL( const TDesC& aNickname )
    {
    HBufC* tempNickname = aNickname.AllocL();
    delete iNickname;
    iNickname = tempNickname;

    UpdateIdentification();
    }

// -----------------------------------------------------------------------------
// CCAContact::SetAliasL
// From MCAExtendedStoredContact
// -----------------------------------------------------------------------------
//
void CCAContact::SetAliasL( const TDesC& aAlias )
    {
    HBufC* tempAlias = aAlias.AllocL();
    delete iAlias;
    iAlias = tempAlias;

    UpdateIdentification();
    }


//  End of File