/*
 * 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:  ?Description
 *
 */

#include <badesca.h>
#include "casrvnotifier.h"
#include "cainnernotifierfilter.h"
#include "cainnerentry.h"
#include "casrvdef.h"
#include "cautils.h"
#include "caarraycleanup.inl"

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


// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
CCaSrvNotifier::~CCaSrvNotifier()
    {
    Complete( KErrCancel );
    iBufArrayInfo.ResetAndDestroy();
    iArrayChangeType.Close();
    delete iFilter;
    }

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

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

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
CCaSrvNotifier::CCaSrvNotifier()
    {
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
void CCaSrvNotifier::ConstructL()
    {
    iFilter = CCaInnerNotifierFilter::NewL(
            CCaInnerNotifierFilter::EEntryChangedWithId );
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
void CCaSrvNotifier::NotifyL( const RMessage2& aMessage )
    {
    PanicIfPendingL( aMessage );
    SetPendingL( aMessage ); // No leaving after this!
    }


// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
void CCaSrvNotifier::Cancel()
    {
    Complete( KErrCancel );
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
void CCaSrvNotifier::SetPendingL( const RMessage2 &aMessage )
    {
    __ASSERT_DEBUG( !iPending, User::Invariant() );
    iMessage = aMessage;
    iPending = ETrue;
    if( iBufArrayInfo.Count() > 0 )
        {
        Complete();
        }
    else
        {
        MenuUtils::InternalizeObjectL( aMessage, *iFilter );
        }
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
void CCaSrvNotifier::PanicIfPendingL( const RMessage2& aMessage )
    {
    if( iPending )
        {
        // Another message is already being served.
        aMessage.Panic( KCaSrvName, KErrInUse );
        User::Leave( KErrInUse );
        }
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
void CCaSrvNotifier::Complete( TInt aReason )
    {
    if( iPending )
        {
        if( aReason != KErrNone )
            {
            iMessage.Complete( aReason );
            iBufArrayInfo.ResetAndDestroy();
            iArrayChangeType.Close();
            }
        else
            {
            if( iBufArrayInfo.Count() > 0 )
                {
                TPckgBuf<TInt> sizeDes( iBufArrayInfo[0]->Size() );
                iMessage.Write( KOutputPosition, sizeDes );
                }
            iMessage.Complete( KErrNone );
            }
        iPending = EFalse;
        }
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
void CCaSrvNotifier::EntryChangedL( const CCaInnerEntry* aEntry,
        TChangeType aChangeType, const RArray<TInt>& aParentIds )
    {
    if( iFilter && CheckFilterForEntry( aEntry, aParentIds ) )
        {
        if( iFilter->GetNotifierType()
                == CCaInnerNotifierFilter::EEntryChangedWithEntry )
            {
            HBufC8* bufInfo = MenuUtils::MarshalDataL( 
                    *aEntry, KDefaultExpandSize );
            CleanupStack::PushL( bufInfo );
            iBufArrayInfo.AppendL( bufInfo );
            CleanupStack::Pop( bufInfo );
            iArrayChangeType.AppendL( aChangeType );
            Complete();
            }
        else if( iFilter->GetNotifierType()
                == CCaInnerNotifierFilter::EEntryChangedWithId )
            {
            AddEntryWithIdL( aEntry->GetId() );
            iArrayChangeType.AppendL( aChangeType );
            Complete();
            }
        }
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
void CCaSrvNotifier::EntryTouchedL( TInt aId )
    {
    if( iFilter && iFilter->GetNotifierType()
            == CCaInnerNotifierFilter::EEntryTouched && CheckIds(
            iFilter->GetIds(), aId ) )
        {
        AddEntryWithIdL( aId );
        Complete();
        }
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
void CCaSrvNotifier::GroupContentChangedL( const RArray<TInt>& aParentIds )
    {
    if( iFilter && iFilter->GetNotifierType()
            == CCaInnerNotifierFilter::EGroupContentChanged )
        {
        if( iFilter->GetParentId() == 0 && aParentIds.Count() > 0 )
            {
            for( TInt i( 0 ); i < aParentIds.Count(); i++ )
                {
                AddEntryWithIdL( aParentIds[i] );
                }
            Complete();
            }
        else if( aParentIds.Find( iFilter->GetParentId() ) != KErrNotFound )
            {
            AddEntryWithIdL( iFilter->GetParentId() );
            Complete();
            }
        }
    }

// ---------------------------------------------------------
// 
// ---------------------------------------------------------
//
void CCaSrvNotifier::GetChangeInfoL( const RMessage2& aMessage )
    {
    if( iBufArrayInfo.Count() > 0 )
        {
        aMessage.WriteL( KInputPosition1, iBufArrayInfo[0]->Des() );
        if( iArrayChangeType.Count() > 0 )
            {
            TPckg<TChangeType> changeTypePckg( iArrayChangeType[0] );
            aMessage.WriteL( KInputPosition2, changeTypePckg );
            iArrayChangeType.Remove( 0 );
            }
        delete iBufArrayInfo[0];
        iBufArrayInfo.Remove( 0 );
        }
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
TBool CCaSrvNotifier::CheckFilterForEntry( const CCaInnerEntry* aEntry,
        const RArray<TInt>& aParentIds )
    {
    TBool filterCorrect = CheckIds( iFilter->GetIds(), aEntry->GetId() );
    if( filterCorrect )
        {
        filterCorrect = ( static_cast<TUint> ( iFilter->GetEntryRole() )
                == ENoneEntryRole
                || static_cast<TUint> ( iFilter->GetEntryRole() )
                        == aEntry->GetRole() );
        }
    if( filterCorrect )
        {
        filterCorrect = CheckTypeName( iFilter->GetTypeNames(),
                aEntry->GetEntryTypeName() );
        }
    if( filterCorrect && iFilter->GetParentId() > 0 )
        {
        filterCorrect = ( iFilter->GetParentId() == aEntry->GetId()
                || aParentIds.Find( iFilter->GetParentId() )
                        != KErrNotFound );
        }
    return filterCorrect;
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
void CCaSrvNotifier::AddEntryWithIdL( TInt aId )
    {
    CCaInnerEntry* entry = CCaInnerEntry::NewLC();
    entry->SetId( aId );
    HBufC8* bufInfo = MenuUtils::MarshalDataL( *entry, KDefaultExpandSize );
    CleanupStack::PushL( bufInfo );
    iBufArrayInfo.AppendL( bufInfo );
    CleanupStack::Pop( bufInfo );
    CleanupStack::PopAndDestroy( entry );
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
TBool CCaSrvNotifier::CheckIds( const RArray<TInt>& aIds, TInt aId )
    {
    TBool result( ETrue );
    if( aIds.Count() > 0 && aIds.Find( aId ) == KErrNotFound )
        {
        result = EFalse;
        }
    return result;
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
TBool CCaSrvNotifier::CheckTypeName( const CDesC16ArrayFlat* aTypeNames,
        const RBuf& aTypeName )
    {
    TBool result( ETrue );
    TInt position( 0 );
    if( aTypeNames->Count() > 0 && aTypeNames->Find( aTypeName, position )
            != KErrNone )
        {
        result = EFalse;
        }
    return result;
    }