/*
* Copyright (c) 2002-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: 
* fundemental commander class.
*
*/


// INCLUDE FILES
#include "impsfundcli.h"
#include "impsfundCommand.h"
#include "impsutils.h"
#include "impsdatautils.h"
#include "ImpsPacked.h"

// MACROS
#ifndef _DEBUG
#define _NO_IMPS_LOGGING_
#endif

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

// ----------------------------------------------------------------------------
// CImpsFundCommand2::CImpsFundCommand2
// ----------------------------------------------------------------------------
CImpsFundCommand2::CImpsFundCommand2( TInt aPriority, RImpsFundClient2& aClient  ):
                                    CActive( aPriority ),
                                    iClient( aClient ),
                                    iMessagePtr()
    {
    CActiveScheduler::Add( this );
    }

// ----------------------------------------------------------------------------
// CImpsFundCommand2::NewL
// ----------------------------------------------------------------------------
CImpsFundCommand2* CImpsFundCommand2::NewL( RImpsFundClient2& aClient )
     {
     CImpsFundCommand2* self = new (ELeave) CImpsFundCommand2( 
                                    EPriorityUserInput, aClient);
     CleanupStack::PushL( self );
     self->ConstructL();
     CleanupStack::Pop();
     return self;
     }

// ----------------------------------------------------------------------------
// CImpsFundCommand2::ConstructL
// ----------------------------------------------------------------------------
void CImpsFundCommand2::ConstructL()
     {
     iKey = CImpsKey::NewL();
     iImpsFields = CImpsFields::NewL();
     iDataAccessor = CImpsDataAccessor::NewL( iImpsFields );
     }
 
// ----------------------------------------------------------------------------
// CImpsFundCommand2::~CImpsFundCommand2
// ----------------------------------------------------------------------------
CImpsFundCommand2::~CImpsFundCommand2()
     {
     //Cancel any outstanding requests
     Cancel();
     ResetMembers();
     delete iKey;
     delete iImpsFields;
     delete iDataAccessor;
     }

// ----------------------------------------------------------------------------
// CImpsFundCommand2::StartRunL
// ----------------------------------------------------------------------------
void CImpsFundCommand2::StartRunL()
    {
    iState = 0;
    if ( IsActive() )
        {
        User::Leave( KErrServerBusy );
        }
    // Set this active object active
    iStatus = KRequestPending;
    SetActive();
    }

// ----------------------------------------------------------------------------
// CImpsFundCommand2::RunL
// ----------------------------------------------------------------------------
void CImpsFundCommand2::RunL()
    {
    #ifndef _NO_IMPS_LOGGING_
        CImpsClientLogger::Log( _L( "CImpsFundCommand2: RunL %d" ), iStatus.Int() );
    #endif
    MImpsErrorHandler2* ehandler = iClient.ErrorHandler();
    // Errors are handled here. 
    // Successful cases are handled by CImpsFundHandler.
    if ( iStatus == KErrNone )
        {
        return;
        }
    // Handler should be registered
    if ( ehandler )
        {
        TInt err( KErrNone );
        TRAP( err, ehandler->HandleErrorL( iStatus.Int(), iOpId, NULL, NULL, *iClient.CspIdentifier() ));
        }
    }

// ----------------------------------------------------------------------------
// CImpsFundCommand2::DoCancel
// ----------------------------------------------------------------------------

void CImpsFundCommand2::DoCancel()
    {
    }

// ----------------------------------------------------------------------------
// CImpsFundCommand2::InitialiseL
// ----------------------------------------------------------------------------
void CImpsFundCommand2::InitialiseL( const TImpsContent* aElementArray,
                                    const TUint aArraySize )
    {
    ResetMembers();
    TImpsDataUtils::AddValuesFromArrayL( iKey, aElementArray, aArraySize );
    }

// ----------------------------------------------------------------------------
// CImpsFundCommand2::SetUserIDsL
// There is no count check here, since client does not
// call this function in case the array is empty.
// ----------------------------------------------------------------------------                                          
void CImpsFundCommand2::SetUserIDsL( const MDesCArray* aUserIDs )
    {
    #ifndef _NO_IMPS_LOGGING_
        CImpsClientLogger::Log( _L( "CImpsFundCommand2::SetUserIDsL()" ) );
    #endif
    TUint count = aUserIDs->MdcaCount();
    for( TUint i = 0;i < count;i++ )
        {
        TPtrC userID = aUserIDs->MdcaPoint( i );
        #ifndef _NO_IMPS_LOGGING_
            CImpsClientLogger::Log( 
                _L( "    User ID no. %d: \"%S\"" ), i, &userID );
        #endif
        iKey->AddL( CREATEKEY( EImpsKeyUser, i ) );
        iKey->AddL( CREATEKEY( EImpsKeyUserID, 0 ) );
        iDataAccessor->StoreDescL( iKey, userID );
        iKey->PopL( 2 );
        }
    }

// -----------------------------------------------------------------------------
// CImpsFundCommand2::MakeSearchPairListL
// -----------------------------------------------------------------------------                                           
void CImpsFundCommand2::MakeSearchPairListL( const CSearchPairs& aSearchPairs )
    {
    #ifndef _NO_IMPS_LOGGING_
        CImpsClientLogger::Log( _L( "CImpsFundCommand2::MakeSearchPairListL" ) );
    #endif
    TInt index = 0;
    TInt count = aSearchPairs.Count();
    CImpsSearchRequest* request = NULL;
    for( TInt i = 0;i < count;i++ )
        {
        request = aSearchPairs.At( i );
        TPtrC value = request->Value();
        if( value.Length() != 0 )
            {
            #ifndef _NO_IMPS_LOGGING_
                CImpsClientLogger::Log( 
                    _L( "  Value of the search pair no. %d: \"%S\"" ), i, &value );
            #endif
            //Must use a separate index variable in order
            //no to mix up the sequence in the iKey member.
            iKey->AddL( CREATEKEY( EImpsKeySearchPairList, index ) );
            iKey->AddL( CREATEKEY( EImpsKeySearchElement, 0 ) );    
            iDataAccessor->StoreIntegerL( iKey, request->Element() );
            iKey->PopL();  //search element
            iKey->AddL( CREATEKEY( EImpsKeySearchString, 0 ) ); 
            iDataAccessor->StoreDescL( iKey, request->Value() );
            iKey->PopL( 2 );
            index++;
            }
        #ifndef _NO_IMPS_LOGGING_
            else
                {
                CImpsClientLogger::Log( _L( "  Value no. %d is empty!" ), i );
                }
        #endif
        }
    }

// -----------------------------------------------------------------------------
// CImpsFundCommand2::InsertEmptyElementL
// -----------------------------------------------------------------------------            
void CImpsFundCommand2::InsertEmptyElementL( const TImpsContent aElementName,
                                            const TInt aIndex )
    {
    iKey->AddL( CREATEKEY( aElementName, aIndex ) );
    iDataAccessor->StoreEmptyL( iKey );
    }

// -----------------------------------------------------------------------------
// CImpsFundCommand2::SetScreenNamesL
// There is no count check here, since client does not
// call this function in case the arrays are empty.
// -----------------------------------------------------------------------------                                            
void CImpsFundCommand2::SetScreenNamesL( const MDesCArray* aScreenNames,
                                        const MDesCArray* aGroupNames )
    {
    #ifndef _NO_IMPS_LOGGING_
        CImpsClientLogger::Log( _L( "CImpsFundCommand2::SetScreenNamesL()" ) );
    #endif
    TUint count = aScreenNames->MdcaCount();
    for( TUint i = 0;i < count;i++ )
        {
        iKey->AddL( CREATEKEY( EImpsKeyScreenName, i ) );
        iKey->AddL( CREATEKEY( EImpsKeySName, 0 ) );
        //Store the SName
        TPtrC SName = aScreenNames->MdcaPoint( i );
        #ifndef _NO_IMPS_LOGGING_
            CImpsClientLogger::Log( _L( "    SName no. %d: \"%S\"" ), i, &SName );
        #endif
        iDataAccessor->StoreDescL( iKey, SName );
        iKey->PopL();
        //Store the GroupID
        iKey->AddL( CREATEKEY( EImpsKeyGroupID, 0 ) );
        #ifndef _NO_IMPS_LOGGING_
            TPtrC groupID = aGroupNames->MdcaPoint( i );
            CImpsClientLogger::Log( 
                _L( "    GroupID no. %d: \"%S\"" ), i, &groupID );
        #endif
        iDataAccessor->StoreDescL( iKey, aGroupNames->MdcaPoint( i ) );
        iKey->PopL();
        }
    }

// -----------------------------------------------------------------------------
// CImpsFundCommand2::InsertDescriptorElementL
// -----------------------------------------------------------------------------                                           
void CImpsFundCommand2::InsertDescriptorElementL( const TDesC& aElementValue,
                                                 const TImpsContent aElementName,
                                                 const TInt aIndex )
    {
    iKey->AddL( CREATEKEY( aElementName, aIndex ) );
    iDataAccessor->StoreDescL( iKey, aElementValue );
    iKey->PopL();
    }

// -----------------------------------------------------------------------------
// CImpsFundCommand2::InsertBooleanElementL
// -----------------------------------------------------------------------------                                              
void CImpsFundCommand2::InsertBooleanElementL( const TBool aElementValue, 
                                              const TImpsContent aElementName,
                                              const TInt aIndex )
    {
    iKey->AddL( CREATEKEY( aElementName, aIndex ) );
    iDataAccessor->StoreBooleanL( iKey, aElementValue );
    iKey->PopL();
    }

// -----------------------------------------------------------------------------
// CImpsFundCommand2::InsertIntegerElementL
// -----------------------------------------------------------------------------                                            
void CImpsFundCommand2::InsertIntegerElementL( const TInt aElementValue,
                                              const TImpsContent aElementName,
                                              const TInt aIndex )
    {
    iKey->AddL( CREATEKEY( aElementName, aIndex ) );
    iDataAccessor->StoreIntegerL( iKey, aElementValue );
    iKey->PopL();
    }

// -----------------------------------------------------------------------------
// CImpsFundCommand2::ResetMembers
// -----------------------------------------------------------------------------                                             
void CImpsFundCommand2::ResetMembers()
    {
    iArraySize = 0;
    delete iMessage;
    iMessage = NULL;
    iMessagePtr.Set( KNullDesC8 );
    if (iKey != NULL)
        {
        iKey->Reset();
        }
    if (iImpsFields != NULL)
        {
        iImpsFields->Reset();
        }
    }

// -----------------------------------------------------------------------------
// CImpsFundCommand2::PackAndSendL
// -----------------------------------------------------------------------------                                         
void CImpsFundCommand2::PackAndSendL( const TImpsMessageType aMessageType,
                                     const TInt aOpId )
    {
    iOpId = aOpId;
    delete iMessage;
    iMessage = NULL;
    HBufC8* buffer = HBufC8::NewLC( iImpsFields->Size() );  // << buffer
    iImpsFields->SetMessageType( aMessageType  );
    TImpsPackedEntity packedMessage( buffer );
    TInt error = packedMessage.PackEntity( *iImpsFields );
    if( error == KErrNone )
        {
        TImpsServRequest req = ServerRequestTypeL( aMessageType );
        StartRunL();
        iMessage = buffer;
        CleanupStack::Pop();  // >> buffer
        iMessagePtr.Set( iMessage->Des() );
        iClient.SendReceive( req, TIpcArgs( &iMessagePtr, iOpId ), iStatus );
        }
    else
        {
        iImpsFields->Reset();
        User::Leave( error );   // >> buffer deleted from CleanupStack
        }
    }

// ----------------------------------------------------------------------------
// CImpsFundCommand2::ServerRequestTypeL
// ----------------------------------------------------------------------------      
TImpsServRequest CImpsFundCommand2::ServerRequestTypeL( 
                                        const TImpsMessageType aMessageType )
    {
    TImpsServRequest ret = EImpsServNone;
    switch( aMessageType )
        {
        case EImpsSearchReq: 
        case EImpsStopSearchReq:                
        case EImpsSearchRes:
            ret = EImpsServFundSearch;
            break;
        case EImpsInviteReq:                
        case EImpsInviteRes:               
        case EImpsInviteUserReq:                
        case EImpsInviteUserRes:               
        case EImpsCancelInviteReq:             
        case EImpsCancelInviteUserReq:
            ret = EImpsServFundInvite;
            break;
        default:
            User::Leave( ret );
        }
    return ret;
    }
    
    
//  End of File