/*

 * 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 <s32mem.h>

#include "casrvsession.h"

#include "caentriesarray.h"

#include "caarraycleanup.inl"

#include "castorageproxy.h"

#include "caidsarray.h"

#include "cainnerentry.h"

#include "cainnerquery.h"

#include "casrvnotifier.h"

#include "casrvdef.h"

#include "cautils.h"

#include "cainnernotifierfilter.h"

const TInt KParamIndNotif = 3;

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

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

// 

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

//

CCaSrvSession::~CCaSrvSession()

    {

    RHashMap<TInt, CCaSrvNotifier*>::TIter iter( iNotifiers );

    while( iter.NextValue() )

        {

        delete *iter.CurrentValue();

        }

    iNotifiers.Close();

    iStorageProxy.RemoveSession( this );

    iCaSrv.DecreaseSessionCount();

    delete iSerializedGetEntriesResult;

    delete iSerializedGetIdsResult;

    }

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

// 

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

//

CCaSrvSession* CCaSrvSession::NewL( CCaSrv& aCaSrv )

    {

    CCaSrvSession* self = new ( ELeave ) CCaSrvSession( aCaSrv );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// 

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

//

CCaSrvSession::CCaSrvSession( CCaSrv& aCaSrv ) :

    iCaSrv( aCaSrv ), iNotifiers(), 

    iStorageProxy( *iCaSrv.GetStorageProxy() )

    {

    }

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

// 

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

//

void CCaSrvSession::ConstructL()

    {

    iCaSrv.IncreaseSessionCount();

    }

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

// 

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

//

void CCaSrvSession::ServiceL( const RMessage2& aMessage )

    {

    TInt err( KErrNone );

    TBool panicedClient( EFalse );

        TRAP( err , DispatchMessageL( aMessage, panicedClient ) );

    if( !panicedClient && aMessage.Function()

            != EContentArsenalNotifierNotify )

        {

        aMessage.Complete( err );

        }

    }

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

// 

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

//

void CCaSrvSession::DispatchMessageL( const RMessage2& aMessage,

        TBool& aPanicedClient )

    {

    switch( aMessage.Function() )

        {

        case EContentArsenalGetList_GetSize:

            GetListSizeL( aMessage, EFull );

            break;

        case EContentArsenalGetList_GetData:

            GetListDataL( aMessage );

            break;

        case EContentArsenalGetIds_GetSize:

            GetListSizeL( aMessage, EIds );

            break;

        case EContentArsenalGetIds_GetData:

            GetIdsDataL( aMessage );

            break;

        case EContentArsenalAdd:

            AddL( aMessage );

            break;

        case EContentArsenalRemove:

            RemoveL( aMessage );

            break;

        case EContentArsenalOrganize:

            OrganizeL( aMessage );

            break;

        case EContentArsenalTouch:

            TouchL( aMessage );

            break;

        case EContentArsenalNotifierOpen:

            NewNotifierL( aMessage );

            break;

        case EContentArsenalNotifierClose:

            RemoveNotifierL( aMessage );

            break;

        case EContentArsenalNotifierNotify:

            NotifierL( aMessage.Int3() )->NotifyL( aMessage );

            break;

        case EContentArsenalNotifierCancel:

            NotifierL( aMessage.Int3() )->Cancel();

            break;

        case EContentArsenalGetChangeInfo:

            GetChangeInfoL( aMessage );

            break;

        case EContentArsenalCustomSort:

            CustomSortL( aMessage );

            break;

        default:

            aMessage.Panic( KCaSrvName, KErrArgument );

            aPanicedClient = ETrue;

            break;

        }

    }

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

// 

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

//

void CCaSrvSession::GetListSizeL( const RMessage2& aMessage,

        TGetListType aType )

    {

    CCaInnerQuery* query = CCaInnerQuery::NewLC();

    MenuUtils::InternalizeObjectL( aMessage, *query );

    TInt size( 0 );

    if( aType == EIds )

        {

        size = GetIdsL( query );

        }

    else

        {

        size = GetEntriesL( query );

        }

    TPckg<TInt> sizeDes( size );

    aMessage.WriteL( KOutputPosition, sizeDes );

    CleanupStack::PopAndDestroy( query );

    }

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

// 

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

//

TInt CCaSrvSession::GetEntriesL( const CCaInnerQuery* aQuery )

    {

    RCaEntriesArray resultContainer;

    CleanupResetAndDestroyPushL( resultContainer );

    iStorageProxy.GetEntriesL( aQuery, resultContainer );

    delete iSerializedGetEntriesResult;

    iSerializedGetEntriesResult = NULL;

    iSerializedGetEntriesResult = 

            MenuUtils::MarshalDataL( resultContainer, KDefaultExpandSize );

    CleanupStack::PopAndDestroy( &resultContainer );

    return iSerializedGetEntriesResult->Size();

    }

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

// 

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

//

TInt CCaSrvSession::GetIdsL( const CCaInnerQuery* aQuery )

    {

    RCaIdsArray resultContainer;

    CleanupClosePushL( resultContainer );

    iStorageProxy.GetEntriesIdsL( aQuery, resultContainer );

    delete iSerializedGetIdsResult;

    iSerializedGetIdsResult = NULL;

    iSerializedGetIdsResult = 

            MenuUtils::MarshalDataL( resultContainer, KDefaultExpandSize );

    CleanupStack::PopAndDestroy( &resultContainer );

    return iSerializedGetIdsResult->Size();

    }

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

// 

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

//

void CCaSrvSession::GetListDataL( const RMessage2& aMessage )

    {

    aMessage.WriteL( KOutputPosition, iSerializedGetEntriesResult->Des() );

    }

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

// 

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

//

void CCaSrvSession::GetIdsDataL( const RMessage2& aMessage )

    {

    aMessage.WriteL( KOutputPosition, iSerializedGetIdsResult->Des() );

    }

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

// 

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

//

void CCaSrvSession::AddL( const RMessage2& aMessage)

    {

    CCaInnerEntry* entry = CCaInnerEntry::NewLC();

    MenuUtils::InternalizeObjectL( aMessage, *entry );

    iStorageProxy.AddL( entry, entry->GetId() > 0 );

    TPckg<TInt> resultId( entry->GetId() );

    aMessage.WriteL( KOutputPosition, resultId );

    CleanupStack::PopAndDestroy( entry );

    }

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

// 

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

//

void CCaSrvSession::RemoveL( const RMessage2& aMessage )

    {

    RCaIdsArray entryIds;

    CleanupClosePushL( entryIds );

    MenuUtils::InternalizeObjectL( aMessage, entryIds );

    iStorageProxy.RemoveL( entryIds );

    CleanupStack::PopAndDestroy( &entryIds );

    }

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

// 

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

//

void CCaSrvSession::OrganizeL( const RMessage2& aMessage )

    {

    RCaIdsArray entryIds;

    CleanupClosePushL( entryIds );

    MenuUtils::InternalizeObjectL( aMessage, entryIds );

    TCaOperationParams operationParams;

    TPckg<TCaOperationParams> data( operationParams );

    aMessage.Read( KInputPosition2, data );

    iStorageProxy.OrganizeL( entryIds, operationParams );

    CleanupStack::PopAndDestroy( &entryIds );

    }

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

// 

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

//

void CCaSrvSession::TouchL( const RMessage2& aMessage )

    {

    CCaInnerEntry* entry = CCaInnerEntry::NewLC();

    MenuUtils::InternalizeObjectL( aMessage, *entry );

    iStorageProxy.TouchL( entry );

    CleanupStack::PopAndDestroy( entry );    

    }

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

// 

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

//

void CCaSrvSession::NewNotifierL( const RMessage2& aMessage )

    {

    CCaSrvNotifier* obj = CCaSrvNotifier::NewLC();

    TInt handle = reinterpret_cast<TInt> ( obj );

    //address pointer of obj is added as unique key in RHashMap

    iNotifiers.InsertL( handle, obj );

    CleanupStack::Pop( obj ); // Now we manage the notifier by handle.

    TPckgC<TInt> handlePckg( handle );

    TInt err = aMessage.Write( KParamIndNotif, handlePckg );

    if( err )

        {

        delete obj;

        iNotifiers.Remove( handle );

        User::Leave( err );

        }

    if( iNotifiers.Count() == 1 )

        {

        iStorageProxy.AddSessionL( this );

        }

    }

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

// 

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

//

CCaSrvNotifier* CCaSrvSession::NotifierL( TInt aHandle )

    {

    CCaSrvNotifier** obj = iNotifiers.Find( aHandle ); 

    if( !obj )

        {

        User::Leave( KErrBadHandle );

        }

    return *obj;

    }

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

// 

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

//

void CCaSrvSession::RemoveNotifierL( const RMessage2& aMessage )

    {

    CCaSrvNotifier* notifier = NotifierL( aMessage.Int3() ); 

    if( notifier )

        {

        delete notifier;

        iNotifiers.Remove( aMessage.Int3() );

        if( iNotifiers.Count() == 0 )

            {

            iStorageProxy.RemoveSession( this );

            }

        }

    }

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

// 

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

//

void CCaSrvSession::GetChangeInfoL( const RMessage2& aMessage )

    {

    CCaSrvNotifier* notifier = NotifierL( aMessage.Int3() ); 

    if( !notifier )

        {

        User::Leave( KErrBadHandle );

        }

    notifier->GetChangeInfoL( aMessage );

    }

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

// 

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

//

void CCaSrvSession::CustomSortL( const RMessage2& aMessage )

    {

    RCaIdsArray entryIds;

    CleanupClosePushL( entryIds );

    MenuUtils::InternalizeObjectL( aMessage, entryIds );

    TInt gruopId;

    TPckg<TInt> data( gruopId );

    aMessage.Read( KInputPosition2, data );

    iStorageProxy.CustomSortL( entryIds, gruopId );

    CleanupStack::PopAndDestroy( &entryIds );

    }

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

// 

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

//

void CCaSrvSession::EntryChanged( const CCaInnerEntry* aEntry,

        TChangeType aChangeType, const RArray<TInt>& aParentIds )

    {

    RHashMap<TInt, CCaSrvNotifier*>::TIter iter( iNotifiers );

    while( iter.NextValue() )

        {

        TRAP_IGNORE( ( *iter.CurrentValue() )->

                EntryChangedL( aEntry, aChangeType, aParentIds ) );

        }

    }

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

// 

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

//

void CCaSrvSession::EntryTouched( TInt aId )

    {

    RHashMap<TInt, CCaSrvNotifier*>::TIter iter( iNotifiers );

    while( iter.NextValue() )

        {

        TRAP_IGNORE( ( *iter.CurrentValue() )->EntryTouchedL( aId ) );

        }

    }

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

// CCaSrvSession::GroupContentChanged

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

//

void CCaSrvSession::GroupContentChanged( const RArray<TInt>& aParentIds )

    {

    RHashMap<TInt, CCaSrvNotifier*>::TIter iter( iNotifiers );

    while( iter.NextValue() )

        {

        TRAP_IGNORE( ( *iter.CurrentValue() )->

                GroupContentChangedL( aParentIds ) );

        }

    }

//  End of File