/*

* 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:  Test support file tool

 *

*/

#include <ximpprotocolconnectionhost.h>

#include <protocolpresenceauthorizationdatahost.h>

#include <protocolpresentitygroupsdatahost.h>

#include <protocolpresencepublishingdatahost.h>

#include <protocolpresencewatchingdatahost.h>

#include <ximpdatasubscriptionstate.h>

#include <protocolpresencedatahost.h>

#include "prfwtestfilelogichelper.h"

#include "prfwtestfilesrvmsg.h"

#include "presentitygroupinfoimp.h"

#include "presentitygroupmemberinfoimp.h"

#include "presencewatcherinfoimp.h"

#include "presencegrantrequestinfoimp.h"

#include "presenceblockinfoimp.h"

#include "ximpidentityimp.h"

#include "ximpobjecthelpers.h"

#include "prfwtestmessenger.h"

#include "ximprestrictedobjectcollectionimp.h"

#include "ximpobjectcollectionimp.h"

#include "presenceinfoimp.h"

// ======== LOCAL FUNCTIONS ========

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

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

// ?description_if_needed

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

//

CXIMPTestFileLogicHelper::CXIMPTestFileLogicHelper( MXIMPProtocolConnectionHost& aHost, CXIMPTestMessenger& aMessenger )

: iHost( aHost ), iMessenger( aMessenger )

    {

    }

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

// ?description_if_needed

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

//

void CXIMPTestFileLogicHelper::ConstructL()

    {

    }

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

// ?description_if_needed

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

//

EXPORT_C CXIMPTestFileLogicHelper* CXIMPTestFileLogicHelper::NewL( MXIMPProtocolConnectionHost& aHost, CXIMPTestMessenger& aMessenger  )

    {

    CXIMPTestFileLogicHelper* self = new( ELeave ) CXIMPTestFileLogicHelper( aHost, aMessenger );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// ?description_if_needed

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

//

CXIMPTestFileLogicHelper::~CXIMPTestFileLogicHelper()

    {

    }

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

// ?description_if_needed

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

//

void CXIMPTestFileLogicHelper::HandleL( TInt aCommandType, TDesC8& aCommand )

    {

    switch( aCommandType )

        {

        case CXIMPTestFileSrvMsg::ETestSrvMsgPresenceGrantRequestList:

            {

            RXIMPObjOwningPtrArray< CPresenceGrantRequestInfoImp > array;

            CleanupClosePushL( array );

            TXIMPObjectPacker<CPresenceGrantRequestInfoImp>::UnPackArrayL( array, aCommand );

            CXIMPObjectCollectionImp* objCollection = CXIMPObjectCollectionImp::NewLC();

            for( TInt a = 0; a < array.Count(); ++a )

                {

                objCollection->AddObjectL( array[ a ] );

                array[ a ] = NULL;

                }

            iHost.ProtocolPresenceDataHost().AuthorizationDataHost().HandlePresenceGrantRequestListL( objCollection );

            CleanupStack::Pop( objCollection );

            CleanupStack::PopAndDestroy(); //array

            break;

            }

        case CXIMPTestFileSrvMsg::ETestSrvMsgPresenceGrantRequestReceived:

            {

            CPresenceGrantRequestInfoImp* infoFromServer =

                                CPresenceGrantRequestInfoImp::NewLC();

            TXIMPObjectPacker<CPresenceGrantRequestInfoImp>::UnPackL(

                                    *infoFromServer, aCommand );

            iHost.ProtocolPresenceDataHost().AuthorizationDataHost().HandlePresenceGrantRequestReceivedL( infoFromServer );

            CleanupStack::Pop( infoFromServer );

            break;

            }

        case CXIMPTestFileSrvMsg::ETestSrvMsgPresenceGrantRequestObsoleted:

            {

            CXIMPIdentityImp* idFromServer = CXIMPIdentityImp::NewLC();

            TXIMPObjectPacker<CXIMPIdentityImp>::UnPackL( *idFromServer,

                                                            aCommand );

            iHost.ProtocolPresenceDataHost().AuthorizationDataHost().HandlePresenceGrantRequestObsoletedL( idFromServer );

            CleanupStack::Pop( idFromServer );

            break;

            }

        case CXIMPTestFileSrvMsg::ETestSrvMsgPresentityGroupList:

            {

            RXIMPObjOwningPtrArray< CPresentityGroupInfoImp > array;

            CleanupClosePushL( array );

            TXIMPObjectPacker<CPresentityGroupInfoImp>::UnPackArrayL( array, aCommand );

            CXIMPObjectCollectionImp* objCollection = CXIMPObjectCollectionImp::NewLC();

            for( TInt a = 0; a < array.Count(); ++a )

                {

                objCollection->AddObjectL( array[ a ] );

                array[ a ] = NULL;

                }

            iHost.ProtocolPresenceDataHost().GroupsDataHost().HandlePresentityGroupListL( objCollection );

            CleanupStack::Pop( objCollection );

            CleanupStack::PopAndDestroy(); //array

            break;            

            }

        case CXIMPTestFileSrvMsg::ETestSrvMsgPresentityGroupCreate:

        case CXIMPTestFileSrvMsg::ETestSrvMsgPresentityGroupUpdate:

            {

            CPresentityGroupInfoImp* infoFromServer =

                                CPresentityGroupInfoImp::NewLC();

            TXIMPObjectPacker<CPresentityGroupInfoImp>::UnPackL(

                                    *infoFromServer, aCommand );

            if( aCommandType == CXIMPTestFileSrvMsg::ETestSrvMsgPresentityGroupCreate )

                {

                iHost.ProtocolPresenceDataHost().GroupsDataHost().HandlePresentityGroupCreatedL( infoFromServer );

                }

            else

                {

                iHost.ProtocolPresenceDataHost().GroupsDataHost().HandlePresentityGroupDisplayNameUpdatedL( infoFromServer );

                }

            CleanupStack::Pop( infoFromServer );

            break;

            }

        case CXIMPTestFileSrvMsg::ETestSrvMsgPresentityGroupDelete:

            {

            CXIMPIdentityImp* idFromServer = CXIMPIdentityImp::NewLC();

            TXIMPObjectPacker<CXIMPIdentityImp>::UnPackL( *idFromServer,

                                                            aCommand );

            iHost.ProtocolPresenceDataHost().GroupsDataHost().HandlePresentityGroupDeletedL( idFromServer );

            CleanupStack::Pop( idFromServer );

            break;

            }

        case CXIMPTestFileSrvMsg::ETestSrvMsgPresentityGroupMemberList:

            {

            RPointerArray< HBufC8 > bufferArray;

            CleanupClosePushL( bufferArray );

            TXIMPHBuf8Packer::UnPackArrayL( bufferArray, aCommand );

            HBufC8* groupIdBuf = bufferArray[ 0 ];

            HBufC8* array = bufferArray[ 1 ];

            CleanupStack::PopAndDestroy(); //  BufferArray

            CleanupStack::PushL( groupIdBuf );

            CleanupStack::PushL( array );

            CXIMPIdentityImp* groupId = CXIMPIdentityImp::NewLC();

            TXIMPObjectPacker< CXIMPIdentityImp >::UnPackL( *groupId, *groupIdBuf );

            RXIMPObjOwningPtrArray< CPresentityGroupMemberInfoImp > memberArray;

            CleanupClosePushL( memberArray );

            TXIMPObjectPacker<CPresentityGroupMemberInfoImp>::UnPackArrayL( memberArray, *array );

            CXIMPObjectCollectionImp* objCollection = CXIMPObjectCollectionImp::NewLC();

            for( TInt a = 0; a < memberArray.Count(); ++a )

                {

                objCollection->AddObjectL( memberArray[ a ] );

                memberArray[ a ] = NULL;

                }

            iHost.ProtocolPresenceDataHost().GroupsDataHost().HandlePresentityGroupContentL( groupId, objCollection );

            CleanupStack::Pop( objCollection );

            CleanupStack::PopAndDestroy(); //memberArray

            CleanupStack::Pop( groupId );

            CleanupStack::PopAndDestroy( 2, groupIdBuf );

            break;

            }

        case CXIMPTestFileSrvMsg::ETestCheckIfGroupMemberExists:

            {

            CXIMPIdentityImp* groupId = CXIMPIdentityImp::NewLC();

            TXIMPObjectPacker< CXIMPIdentityImp >::UnPackL( *groupId, aCommand );

            // Write to pubsub

            const MXIMPDataSubscriptionState& state = 

                iHost.ProtocolPresenceDataHost().GroupsDataHost().PresentityGroupContentDataSubscriptionState( *groupId );

            if( state.DataState() == MXIMPDataSubscriptionState::EDataAvailable )

                {

                iMessenger.SetValueFor( EXIMPPlgTestExistsGroupContentInCache, 1 );

                }

            else

                {

                iMessenger.SetValueFor( EXIMPPlgTestExistsGroupContentInCache, KErrNotFound );

                }

            CleanupStack::PopAndDestroy( groupId );

            break;

            }

        case CXIMPTestFileSrvMsg::ETestSrvMsgPresenceWatcherList:

            {

            RXIMPObjOwningPtrArray< CPresenceWatcherInfoImp > array;

            CleanupClosePushL( array );

            TXIMPObjectPacker< CPresenceWatcherInfoImp >::UnPackArrayL( array, aCommand );

            CXIMPObjectCollectionImp* objCollection = CXIMPObjectCollectionImp::NewLC();

            for( TInt a = 0; a < array.Count(); ++a )

                {

                objCollection->AddObjectL( array[ a ] );

                array[ a ] = NULL;

                }

            iHost.ProtocolPresenceDataHost().PublishingDataHost().HandlePresenceWatcherListL( objCollection );

            CleanupStack::Pop( objCollection );

            CleanupStack::PopAndDestroy(); //, array

            break;

            }

        case CXIMPTestFileSrvMsg::ETestSrvMsgPresentityPresence:

            {

            RPointerArray< HBufC8 > bufferArray;

            CleanupClosePushL( bufferArray );

            TXIMPHBuf8Packer::UnPackArrayL( bufferArray, aCommand );

            HBufC8* presenceIdBuf = bufferArray[ 0 ];

            HBufC8* presenceInfoBuf = bufferArray[ 1 ];

            CleanupStack::PopAndDestroy(); //  BufferArray

            CleanupStack::PushL( presenceIdBuf );

            CleanupStack::PushL( presenceInfoBuf );

            CXIMPIdentityImp* presenceId = CXIMPIdentityImp::NewLC();

            TXIMPObjectPacker< CXIMPIdentityImp >::UnPackL( *presenceId, *presenceIdBuf );

            CPresenceInfoImp* presenceInfo = CPresenceInfoImp::NewLC();

            TXIMPObjectPacker< CPresenceInfoImp >::UnPackL( *presenceInfo, *presenceInfoBuf );

            iHost.ProtocolPresenceDataHost().WatchingDataHost().HandleSubscribedPresentityPresenceL( presenceId, presenceInfo );

            CleanupStack::Pop( 2, presenceId );

            CleanupStack::PopAndDestroy( 2, presenceIdBuf );

            break;

            }

        case CXIMPTestFileSrvMsg::ETestSrvMsgPresenceBlockList:

            {

            RXIMPObjOwningPtrArray< CPresenceBlockInfoImp > array;

            CleanupClosePushL( array );

            TXIMPObjectPacker< CPresenceBlockInfoImp >::UnPackArrayL( array, aCommand );

            CXIMPObjectCollectionImp* objCollection = CXIMPObjectCollectionImp::NewLC();

            for( TInt a = 0; a < array.Count(); ++a )

                {

                objCollection->AddObjectL( array[ a ] );

                array[ a ] = NULL;

                }

            iHost.ProtocolPresenceDataHost().AuthorizationDataHost().HandlePresenceBlockListL( objCollection );

            CleanupStack::Pop( objCollection );

            CleanupStack::PopAndDestroy(); // array

            break;

            }

        case CXIMPTestFileSrvMsg::ETestSrvMsgPresenceBlocked:

            {

            CPresenceBlockInfoImp* infoFromServer =

                                CPresenceBlockInfoImp::NewLC();

            TXIMPObjectPacker<CPresenceBlockInfoImp>::UnPackL(

                                    *infoFromServer, aCommand );

            iHost.ProtocolPresenceDataHost().AuthorizationDataHost().HandlePresenceBlockedL( infoFromServer );

            CleanupStack::Pop( infoFromServer );

            break;

            }

        case CXIMPTestFileSrvMsg::ETestSrvMsgPresenceBlockCanceled:

            {

            CXIMPIdentityImp* idFromServer = CXIMPIdentityImp::NewLC();

            TXIMPObjectPacker<CXIMPIdentityImp>::UnPackL( *idFromServer,

                                                            aCommand );

            iHost.ProtocolPresenceDataHost().AuthorizationDataHost().HandlePresenceBlockCanceledL( idFromServer );

            CleanupStack::Pop( idFromServer );

            break;

            }

        case CXIMPTestFileSrvMsg::ETestSrvMsgReqParamIdentity:

            {

            CXIMPIdentityImp* groupId = CXIMPIdentityImp::NewLC();

            TXIMPObjectPacker< CXIMPIdentityImp >::UnPackL( *groupId, aCommand );

            CXIMPRestrictedObjectCollectionImp* paramCollection = CXIMPRestrictedObjectCollectionImp::NewLC();

            paramCollection->AddOrReplaceTypeL( groupId );

            iMessenger.SetReqCompleteParams( paramCollection );

            CleanupStack::Pop( 2, groupId );

            break;

            }

        default:

            {

            User::Panic( _L( "Not valid commandtype" ), 59 );

            break;

            }

        }

    }

// End of file