/*

* 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:  CMnMapImageServiceBase class implementation

*

*/

#include <e32base.h>

#include <fbs.h>

#include "mndebug.h"

#include "mnerrors.h"

#include "mninternal.h"

#include "mninternal.inl"

#include "mnmapimageservicebase.h"

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

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

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

//

EXPORT_C CMnMapImageServiceBase::CMnMapImageServiceBase()

    {

    }

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

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

//

EXPORT_C CMnMapImageServiceBase::~CMnMapImageServiceBase()

    {

    if ( iBitmap )

        {

        delete iBitmap;

        }

    }

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

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

//

EXPORT_C void CMnMapImageServiceBase::BaseConstructL()

    {

    CMnServiceBase::BaseConstructL();

    }

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

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

//

EXPORT_C const TMnMapImageParams& CMnMapImageServiceBase::MapImageParams() const

    {

    return iMapImageParams;

    }

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

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

//

EXPORT_C TMnMapImageParams& CMnMapImageServiceBase::MapImageParams()

    {

    return iMapImageParams;

    }

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

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

//

EXPORT_C void CMnMapImageServiceBase::SetMapImageParams( const TMnMapImageParams& aImageParams )

    {

    iMapImageParams = aImageParams;

    }

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

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

//

EXPORT_C TRect CMnMapImageServiceBase::TargetRect() const

    {

    if ( iBitmap )

        {

        return TRect( iTargetOrigin, iBitmap->SizeInPixels() );

        }

    else

        {

        return TRect( 0, 0, 0, 0 );

        }

    }

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

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

//

EXPORT_C CMnMapImage::TShowOptions CMnMapImageServiceBase::ShowOptions() const

    {

    return iShowOptions;

    }

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

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

//

EXPORT_C CFbsBitmap& CMnMapImageServiceBase::TargetBitmap() const

    {

    if ( !iBitmap )

        {

        PanicServer( KErrGeneral );

        }

    return *iBitmap;

    }

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

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

//

EXPORT_C void CMnMapImageServiceBase::CompleteRendering()

    {

    LOG("CMnMapImageServiceBase::CompleteRenderingL in");

    if ( CurrentAsyncRequest() != EMnIpcRenderImage )

        {

        PanicServer( KMnPanicAttemptToCompleteNoRequest );

        }

    if ( iMapImageParams.ImageType() == TMnMapImageParams::ETypeUnspecified ) 

        {

        PanicServer( KMnPanicInvalidResult );

        }   

    TPckg<TMnMapImageParams> paramsPack( iMapImageParams );

    TInt err = iMessage.Write( EMnIpcImageParamsParamIndex, paramsPack );

    CompleteRequest( err );

    delete iBitmap;

    iBitmap = NULL;

    LOG("CMnMapImageServiceBase::CompleteRenderingL out");

    }

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

//  From class CAknAppServiceBase

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

//

EXPORT_C void CMnMapImageServiceBase::ServiceL( const RMessage2& aMessage )

    {

    //LOG1("CMnMapImageServiceBase::ServiceL in, function %d", aMessage.Function());

    switch ( aMessage.Function() )

        {

        case EMnIpcRenderImage:

            PrepareAsyncRequestL( aMessage );

            StartAsyncRequestL( aMessage );

            break;

        case EMnIpcCancel:

            HandleCancelRequestL( aMessage );

            break;

        default:

            CMnServiceBase::ServiceL( aMessage );

        }

    }

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

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

//

void CMnMapImageServiceBase::StartAsyncRequestL( const RMessage2& aMessage )

    {

    LOG("CMnMapImageServiceBase::StartAsyncRequestL in");

    switch ( CurrentAsyncRequest() )

        {

        case EMnIpcRenderImage:

            UnpackImageParamsL( aMessage );

            UnpackOptionsL( aMessage );

            UnpackBitmapHandleL( aMessage );

            HandleRenderingL();

            break;

        default:

            User::Leave( KErrNotSupported );

        }

    LOG("CMnMapImageServiceBase::StartAsyncRequestL out");

    }

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

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

//

void CMnMapImageServiceBase::UnpackOptionsL( const RMessage2& aMessage )

    {

    LOG("CMnMapImageServiceBase::UnpackOptionsL");

    TMnMapImageOptions options;

    TPckg<TMnMapImageOptions> optsPack( options );

    aMessage.ReadL( EMnIpcImageOptionsParamIndex, optsPack );

    if ( options.iShowOptions & CMnMapImage::EShowOptionCurrentLocation )

        {

        // leaves with KErrPermissionDenied if client does not have Location capability

        aMessage.HasCapabilityL( ECapabilityLocation );

        }

    iShowOptions = options.iShowOptions;

    iTargetOrigin = options.iTargetOrigin;

    }

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

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

//

void CMnMapImageServiceBase::UnpackImageParamsL( const RMessage2& aMessage )

    {

    LOG("CMnMapImageServiceBase::UnpackImageParamsL");

    TPckg<TMnMapImageParams> paramsPack( iMapImageParams );

    aMessage.ReadL( EMnIpcImageParamsParamIndex, paramsPack );

    }

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

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

//

void CMnMapImageServiceBase::UnpackBitmapHandleL( const RMessage2& aMessage )

    {

    TInt bitmapHandle = aMessage.Int2(); // EMnIpcImageBitmapHandleParamIndex == 2

    LOG1("CMnMapImageServiceBase::UnpackBitmapHandleL, handle %d", bitmapHandle);

    ASSERT( !iBitmap );

    iBitmap = new (ELeave) CFbsBitmap;

    User::LeaveIfError( iBitmap->Duplicate( bitmapHandle ) );

    }

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

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

//

void CMnMapImageServiceBase::HandleCancelRequestL( const RMessage2& aMessage )

    {

    TInt request = CurrentAsyncRequest();

    CMnServiceBase::HandleCancelRequestL( aMessage );

    if ( request == EMnIpcRenderImage )

        {

        delete iBitmap;

        iBitmap = NULL;

        }

    }