/*
* Copyright (c) 2005-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:  CMnServiceBase class implementation
*
*/


#include <e32base.h>

#include <EPos_CPosLandmark.h>
#include <epos_poslandmarkserialization.h>

#include "mndebug.h"
#include "mnerrors.h"
#include "mninternal.h"
#include "mninternal.inl"

#include "mnservicebase.h"

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

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

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
CMnServiceBase::CMnServiceBase()
    {
    iCurrentRequest = EMnIpcNone;
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
CMnServiceBase::~CMnServiceBase()
    {
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
void CMnServiceBase::BaseConstructL()
    {
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
EXPORT_C void CMnServiceBase::CompleteRequest( TInt aResult )
    {
    LOG1("CMnServiceBase::CompleteRequest, result %d", aResult);
    if ( iCurrentRequest == EMnIpcNone )
        {
        PanicServer( KMnPanicAttemptToCompleteNoRequest );
        }
    else
        {
        Complete( iMessage, aResult );
        iCurrentRequest = EMnIpcNone;
        }
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
void CMnServiceBase::Complete( const RMessage2& aMsg, TInt aResult )
    {
    //LOG1("CMnServiceBase::Complete, result %d", aResult);
    if ( !aMsg.IsNull() )
        {
        aMsg.Complete( aResult );
        }
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
void CMnServiceBase::HandleCancelRequestL( const RMessage2& aMessage )
    {
    LOG("CMnServiceBase::HandleCancelRequestL in");
    
    if ( IsAsyncRequestActive() && aMessage.Int0() == CurrentAsyncRequest() )
        {
        DoCancel();
        CompleteRequest( KErrCancel );
        Complete( aMessage, KErrNone );
        }
    else
        {
        LOG("CMnServiceBase::HandleCancelRequestL leave, not found");
        User::Leave( KErrNotFound );
        }
        
    LOG("CMnServiceBase::HandleCancelRequestL out");
    }

// ---------------------------------------------------------
// ---------------------------------------------------------
//
HBufC8* CMnServiceBase::CopyClientBuffer8LC(
    const RMessage2& aMessage, 
    const TInt aClientBufferParam )
    {
    // Create an empty server side buffer that will contain client data
    TInt dataSize = aMessage.GetDesLengthL( aClientBufferParam );
    HBufC8* buffer = HBufC8::NewLC( dataSize );

    // Populate server side buffer with client data
    TPtr8 ptrToBuf = buffer->Des();
    aMessage.ReadL( aClientBufferParam, ptrToBuf );
    return buffer;
    }

// ---------------------------------------------------------
// ---------------------------------------------------------
//
HBufC* CMnServiceBase::CopyClientBufferLC(
    const RMessage2& aMessage, 
    const TInt aClientBufferParam)
    {
    // Create an empty server side buffer that will contain client data
    TInt dataSize = aMessage.GetDesLengthL( aClientBufferParam );
    HBufC* buffer = HBufC::NewLC( dataSize );

    // Populate server side buffer with client data
    TPtr ptrToBuf = buffer->Des();
    aMessage.ReadL( aClientBufferParam, ptrToBuf );
    return buffer;
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
CPosLandmark* CMnServiceBase::UnpackLandmarkLC( 
    const RMessage2& aMessage,
    TInt aParamIndex )
    {
    LOG("CMnServiceBase::UnpackLandmarkLC");
    
    HBufC8* lmBuf = CopyClientBuffer8LC( aMessage, aParamIndex );
    
    CPosLandmark* landmark = PosLandmarkSerialization::UnpackL( *lmBuf );
    CleanupStack::PopAndDestroy( lmBuf );
    CleanupStack::PushL( landmark );
    return landmark;
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
TInt CMnServiceBase::CurrentAsyncRequest()
    {
    return iCurrentRequest;
    }
    
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
TBool CMnServiceBase::IsAsyncRequestActive()
    {
    return ( iCurrentRequest != EMnIpcNone );
    }

// ---------------------------------------------------------------------------
//  Put new request ID to stack to guarantee that if starting of asynchronous
//  request leaves, the iCurrentRequest will be reset.
//  If starting goes well, the PostStartAsyncRequest will pop this cleanup
//  from stack and "current request ID" will be kept until request is competed
//  by service implmentation.
// ---------------------------------------------------------------------------
//
void CMnServiceBase::PrepareAsyncRequestL( const RMessage2& aMessage )
    {
    LOG("CMnServiceBase::PrepareAsyncRequestL in");

    if ( IsAsyncRequestActive() )
        {
        PanicClient( aMessage, KMnPanicDuplicateRequest );
        User::Leave( KErrInUse );
        }

    iMessage = aMessage;
    iCurrentRequest = aMessage.Function();

    LOG("CMnServiceBase::PrepareAsyncRequestL out");
    }

// ---------------------------------------------------------------------------
//  From class CApaAppServiceBase
// ---------------------------------------------------------------------------
//
EXPORT_C void CMnServiceBase::ServiceError( const RMessage2 &aMessage, TInt aError )
    {
    LOG2("CMnServiceBase::ServiceError function %d, error %d",
        aMessage.Function(), aError );
    
    if ( IsAsyncRequestActive() && 
         aMessage.Handle() == iMessage.Handle() )
        {
        // starting this async request failed, rollback
        LOG1("CMnServiceBase::ServiceError forgetting async request %d", iCurrentRequest );
        iCurrentRequest = EMnIpcNone;
        }

    CAknAppServiceBase::ServiceError( aMessage, aError );
    LOG("CMnServiceBase::ServiceError out");
    }