/*

* Copyright (c) 2006 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:  IM Service Connection subscription item base implementation.

*

*/

#include "ximpimsubscriptionitembase.h"

#include "ximpimitemparent.h"

#include "ximppanics.h"

//#include "ximppsccontext.h"

//#include "ximpdatasubscriptionstateimp.h"

//#include "ximpobjecthelpers.h"

//#include "ximptrace.h"

const TInt KXIMPContentAutoExpiryTime = 15; // Seconds

// ---------------------------------------------------------------------------

// CXIMPIMSubscriptionItemBase::OrderOfContexts()

// ---------------------------------------------------------------------------

//

TInt CXIMPIMSubscriptionItemBase::OrderOfContexts( const MXIMPPscContext& aFirst,

                                                 const MXIMPPscContext& aSecond )

    {

    if( &aFirst < &aSecond )

        {

        return -1;

        }

    else if( &aFirst == &aSecond )

        {

        return 0;

        }

    else

        {

        return 1;

        }

    }

// ---------------------------------------------------------------------------

// CXIMPIMSubscriptionItemBase::OrderOfItems()

// ---------------------------------------------------------------------------

//

TInt CXIMPIMSubscriptionItemBase::OrderOfItems( const CXIMPIMSubscriptionItemBase& aFirst,

                                              const CXIMPIMSubscriptionItemBase& aSecond )

    {

    if( &aFirst < &aSecond )

        {

        return -1;

        }

    else if( &aFirst == &aSecond )

        {

        return 0;

        }

    else

        {

        return 1;

        }

    }

// ---------------------------------------------------------------------------

// CXIMPIMSubscriptionItemBase::CXIMPIMSubscriptionItemBase()

// ---------------------------------------------------------------------------

//

EXPORT_C CXIMPIMSubscriptionItemBase::CXIMPIMSubscriptionItemBase( MXIMPIMItemParent& aParent )

: iParent( aParent )

    {

    }

// ---------------------------------------------------------------------------

// CXIMPIMSubscriptionItemBase::BaseConstructL()

// ---------------------------------------------------------------------------

//

EXPORT_C void CXIMPIMSubscriptionItemBase::BaseConstructL()

    {

    iSubscriptionState = CXIMPDataSubscriptionStateImp::NewL();

    }

// ---------------------------------------------------------------------------

// CXIMPIMSubscriptionItemBase::~CXIMPIMSubscriptionItemBase()

// ---------------------------------------------------------------------------

//

EXPORT_C CXIMPIMSubscriptionItemBase::~CXIMPIMSubscriptionItemBase()

    {

    __ASSERT_ALWAYS( !CountOfSubscribers(),

                     User::Panic( NXIMPPrivPanic::KCategory, NXIMPPrivPanic::EArrayCountNotValid ) );

    iContexts.Close();

    iPreContexts.Close();

    iItems.Close();

    iPreItems.Close();

    delete iSubscriptionState;

    }

// ---------------------------------------------------------------------------

// CXIMPIMSubscriptionItemBase::SubscriptionStatus()

// ---------------------------------------------------------------------------

//

EXPORT_C CXIMPIMSubscriptionItemBase::TSubscriptionStatus

           CXIMPIMSubscriptionItemBase::SubscriptionStatus( MXIMPPscContext* aContext )

    {

    // Calculate situation

    TInt count = iContexts.Count() + iItems.Count();

    if( count == 0 )

        {

        return ENotSubscribedAtAll;

        }

    if( IsContext( aContext ) )

        {

        if( count == 1 )

            {

            return ESubscribedForCtxOnly;

            }

        return ESubscribedForCtxAndOthers;

        }

    return ESubscribedForOtherCtxOnly;

    }

// ---------------------------------------------------------------------------

// CXIMPIMSubscriptionItemBase::AddSubscriberL()

// ---------------------------------------------------------------------------

//

EXPORT_C void CXIMPIMSubscriptionItemBase::AddSubscriberL( MXIMPPscContext* aContext )

    {

    TLinearOrder< MXIMPPscContext > order( OrderOfContexts );

    if( IsContext( aContext ) )

        {

        User::Leave( KErrAlreadyExists );

        }

    TInt index = iPreContexts.FindInOrder( aContext, order );

    if( index != KErrNotFound )

        {

        User::Leave( KErrAlreadyExists );

        }

    iPreContexts.InsertInOrderL( aContext, order );

    User::LeaveIfError( Open() );

    ChangeStatusAfterAdd();

    }

// ---------------------------------------------------------------------------

// CXIMPIMSubscriptionItemBase::RemoveSubscriber()

// ---------------------------------------------------------------------------

//

EXPORT_C void CXIMPIMSubscriptionItemBase::RemoveSubscriber( MXIMPPscContext* aContext )

    {

    TLinearOrder< MXIMPPscContext > order( OrderOfContexts );

    TInt index = iContexts.FindInOrder( aContext, order );

    TInt preIndex = iPreContexts.FindInOrder( aContext, order );

    if( index >= 0 )

        {

        iContexts.Remove( index );

        ChangeStatusAfterRemove();

        Close();

        }

    else if( preIndex >= 0 )

        {

        iPreContexts.Remove( preIndex );

        ChangeStatusAfterRemove();

        Close();

        }

    else

        {

        iParent.UnregisterExpiringItem( this );

        }

    }

// ---------------------------------------------------------------------------

// CXIMPIMSubscriptionItemBase::AddSubscriberL()

// ---------------------------------------------------------------------------

//

EXPORT_C void CXIMPIMSubscriptionItemBase::AddSubscriberL( CXIMPIMSubscriptionItemBase* aItem )

    {

    TLinearOrder< CXIMPIMSubscriptionItemBase > order( OrderOfItems );

    TInt index = iItems.FindInOrder( aItem, order );

    if( index != KErrNotFound )

        {

        return;

        }

    index = iPreItems.FindInOrder( aItem, order );

    if( index != KErrNotFound )

        {

        return;

        }

    iPreItems.InsertInOrderL( aItem, order );

    User::LeaveIfError( Open() );

    ChangeStatusAfterAdd();

    }

// ---------------------------------------------------------------------------

// CXIMPIMSubscriptionItemBase::RemoveSubscriber()

// ---------------------------------------------------------------------------

//

EXPORT_C void CXIMPIMSubscriptionItemBase::RemoveSubscriber( CXIMPIMSubscriptionItemBase* aItem )

    {

    TLinearOrder< CXIMPIMSubscriptionItemBase > order( OrderOfItems );

    TInt index = iItems.FindInOrder( aItem, order );

    TInt preIndex = iPreItems.FindInOrder( aItem, order );

    if( index >= 0 )

        {

        iItems.Remove( index );

        ChangeStatusAfterRemove();

        Close();

        }

    else if( preIndex >= 0 )

        {

        iPreItems.Remove( index );

        ChangeStatusAfterRemove();

        Close();

        }

    else

        {

        iParent.UnregisterExpiringItem( this );

        }

    }

// ---------------------------------------------------------------------------

// CXIMPIMSubscriptionItemBase::ForceClose()

// ---------------------------------------------------------------------------

//

EXPORT_C void CXIMPIMSubscriptionItemBase::ForceClose()

    {

    TInt count = iContexts.Count();

    for( TInt a = 0; a < count; ++a )

        {

        // RemoveSubscriber removes first one every time.

        RemoveSubscriber( iContexts[ 0 ] );

        }

    count = iItems.Count();

    for( TInt a = 0; a < count; ++a )

        {

        RemoveSubscriber( iItems[ 0 ] );

        }

    }

// ---------------------------------------------------------------------------

// CXIMPIMSubscriptionItemBase::CleanIfExpired()

// ---------------------------------------------------------------------------

//

EXPORT_C TBool CXIMPIMSubscriptionItemBase::CleanIfExpired()

    {

    TTime timeNow;

    timeNow.UniversalTime();

    TBool expired =

        ( iExpireTime + TTimeIntervalSeconds( KXIMPContentAutoExpiryTime ) ) < timeNow;

    if( expired )

        {

        CleanExpired();

        }

    return expired;

    }

// ---------------------------------------------------------------------------

// CXIMPIMSubscriptionItemBase::UpdateSubscriptionStateL()

// ---------------------------------------------------------------------------

//

EXPORT_C void CXIMPIMSubscriptionItemBase::UpdateSubscriptionStateL( TSubscriptionEvent aUpdateState )

    {

    switch( aUpdateState )

        {

        case ECompleteDataReceived:

            {

            if( CountOfSubscribers() == 0 )

                {

                UpdateExpirationL();

                }

            break;

            }

        default:

            {

            User::Panic( NXIMPPrivPanic::KCategory, NXIMPPrivPanic::ESubscriptionItemLogicError );

            break;

            }

        }

    }

// ---------------------------------------------------------------------------

// CXIMPIMSubscriptionItemBase::DataSubscriptionState()

// ---------------------------------------------------------------------------

//

EXPORT_C const MXIMPDataSubscriptionState& CXIMPIMSubscriptionItemBase::DataSubscriptionState()

    {

    return *iSubscriptionState;

    }

// ---------------------------------------------------------------------------

// CXIMPIMSubscriptionItemBase::ContextCount()

// ---------------------------------------------------------------------------

//

EXPORT_C TInt CXIMPIMSubscriptionItemBase::ContextCount() const

    {

    return iContexts.Count();

    }

// ---------------------------------------------------------------------------

// CXIMPIMSubscriptionItemBase::Context()

// ---------------------------------------------------------------------------

//

EXPORT_C MXIMPPscContext& CXIMPIMSubscriptionItemBase::Context( TInt aIndex )

    {

    return *iContexts[ aIndex ];

    }

// ---------------------------------------------------------------------------

// CXIMPIMSubscriptionItemBase::Context()

// ---------------------------------------------------------------------------

//

EXPORT_C TBool CXIMPIMSubscriptionItemBase::IsContext( MXIMPPscContext* aContext ) const

    {

    TLinearOrder< MXIMPPscContext > order( OrderOfContexts );

    return iContexts.FindInOrder( aContext, order ) != KErrNotFound;

    }

// ---------------------------------------------------------------------------

// CXIMPIMSubscriptionItemBase::SynthesiseSubscriptionEventToAllCtxsL()

// ---------------------------------------------------------------------------

//

EXPORT_C void CXIMPIMSubscriptionItemBase::SynthesiseSubscriptionEventToAllCtxsL()

    {

    //TRACE( _L("CXIMPIMSubscriptionItemBase::SynthesiseSubscriptionEventToAllCtxsL()" ) );

    RPointerArray< MXIMPPscContext > contextArray;

    CleanupClosePushL( contextArray );

    TLinearOrder< MXIMPPscContext > order( OrderOfContexts );

    TInt contextCount = iContexts.Count();

    for( TInt a = 0; a < contextCount; ++a )

        {

        contextArray.InsertInOrderL( iContexts[ a ], order );

        }

    TInt itemCount = iItems.Count();

    for( TInt a = 0; a < itemCount; ++a )

        {

        TInt contextCount = iItems[ a ]->ContextCount();

        for( TInt b = 0; b < contextCount; ++b )

            {

            TInt error = contextArray.InsertInOrder( &iItems[ a ]->Context( b ), order );

            if( error != KErrNotFound )

                {

                User::LeaveIfError( error );

                }

            }

        }

    TInt count = contextArray.Count();

    for( TInt a = 0; a < count; ++a )

        {

        SynthesiseSubscriptionEventToL( contextArray[ a ], ETrue );

        }

    CleanupStack::PopAndDestroy(); // contextArray

    }

// ---------------------------------------------------------------------------

// CXIMPIMSubscriptionItemBase::ActivateSubscriberL()

// ---------------------------------------------------------------------------

//

EXPORT_C void CXIMPIMSubscriptionItemBase::ActivateSubscriberL( MXIMPPscContext* aContext )

    {

    TLinearOrder< MXIMPPscContext > order( OrderOfContexts );

    TInt index = iPreContexts.FindInOrder( aContext, order );

    if( index != KErrNotFound && index < iPreContexts.Count())

        {

        iContexts.InsertInOrderL( iPreContexts[ index ], order );

        iPreContexts.Remove( index );

        }

    }

// ---------------------------------------------------------------------------

// CXIMPIMSubscriptionItemBase::ActivateSubscriberL()

// ---------------------------------------------------------------------------

//

EXPORT_C void CXIMPIMSubscriptionItemBase::ActivateSubscriberL( CXIMPIMSubscriptionItemBase* aItem )

    {

    TLinearOrder< CXIMPIMSubscriptionItemBase > order( OrderOfItems );

    TInt index = iPreItems.FindInOrder( aItem, order );

    if( index != KErrNotFound && index < iPreItems.Count())

        {

        iItems.InsertInOrderL( iPreItems[ index ], order );

        iPreItems.Remove( index );

        }

    }

// ---------------------------------------------------------------------------

// CXIMPIMSubscriptionItemBase::Status()

// ---------------------------------------------------------------------------

//

EXPORT_C void CXIMPIMSubscriptionItemBase::SetDataSubscriptionStateL( CXIMPDataSubscriptionStateImp& aNewState )

    {

    // Some handle logic for terminating subscribers, data expiration etc. missing.

    delete iSubscriptionState;

    iSubscriptionState = &aNewState;

    }

// ---------------------------------------------------------------------------

// CXIMPIMSubscriptionItemBase::Status()

// ---------------------------------------------------------------------------

//

EXPORT_C CXIMPDataSubscriptionStateImp* CXIMPIMSubscriptionItemBase::StatusLC( MXIMPPscContext* /*aContext*/ ) const

    {

    // not implemented as of now

    }

// ---------------------------------------------------------------------------

// CXIMPIMSubscriptionItemBase::UpdateExpirationL()

// ---------------------------------------------------------------------------

//

EXPORT_C void CXIMPIMSubscriptionItemBase::UpdateExpirationL()

    {

    if( CountOfSubscribers() == 0 )

        {

        iParent.RegisterExpiringItemL( this );

        }

    iExpireTime.UniversalTime();

    }

// ---------------------------------------------------------------------------

// CXIMPIMSubscriptionItemBase::ChangeStatusAfterRemove()

// ---------------------------------------------------------------------------

//

EXPORT_C void CXIMPIMSubscriptionItemBase::ChangeStatusAfterRemove()

    {

    // not implemented as of now

    }

// ---------------------------------------------------------------------------

// CXIMPIMSubscriptionItemBase::ChangeStatusAfterAdd()

// ---------------------------------------------------------------------------

//

EXPORT_C void CXIMPIMSubscriptionItemBase::ChangeStatusAfterAdd()

    {

	// not implemented as of now

    }

// ---------------------------------------------------------------------------

// CXIMPIMSubscriptionItemBase::CountOfSubscribers()

// ---------------------------------------------------------------------------

//

EXPORT_C TInt CXIMPIMSubscriptionItemBase::CountOfSubscribers()

    {

    return iItems.Count() + iPreItems.Count() + iContexts.Count() + iPreContexts.Count();

    }

// End of file