/*

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

*

*/

#include <e32base.h>

#include <s32mem.h>

#include <e32math.h>

#include <lbsposition.h>

#include <EPos_CPosLandmark.h>

#include <epos_poslandmarkserialization.h>

#include "mndebug.h"

#include "mnerrors.h"

#include "mninternal.h"

#include "mninternal.inl"

#include "mnmapselectionresultinfo.inl"

#include "mnmapviewservicebase.h"

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

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

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

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

//

EXPORT_C CMnMapViewServiceBase::CMnMapViewServiceBase()

    {

    }

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

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

//

EXPORT_C CMnMapViewServiceBase::~CMnMapViewServiceBase()

    {

    LOG("~CMnMapViewServiceBase in");

    ResetLandmarks();

    iLandmarks.Close();

    iLinkedLandmarksLists.Close();

    iTempDatabaseList.Close();

    CleanSelectionResult();

    delete iSelectionRequestText;

    LOG("~CMnMapViewServiceBase out");

    }

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

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

//

EXPORT_C void CMnMapViewServiceBase::BaseConstructL()

    {

    LOG("CMnMapViewServiceBase::BaseConstructL");

    CMnServiceBase::BaseConstructL();

    iSelectionRequestText = HBufC::NewL( 0 );

    }

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

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

//

EXPORT_C CMnMapView::TOptions CMnMapViewServiceBase::Options()

    {

    LOG("CMnMapViewServiceBase::Options");

    return iOptions;

    }

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

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

//

EXPORT_C CMnMapView::TCurrentLocationOption CMnMapViewServiceBase::CurrentLocationOption()

    {

    LOG("CMnMapViewServiceBase::CurrentLocationOption");

    return iCurrentLocationOption;

    }

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

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

//

EXPORT_C TArray<const CPosLandmark*> CMnMapViewServiceBase::LandmarksToShow()

    {

    LOG("CMnMapViewServiceBase::LandmarksToShow");

    return iLandmarks.Array();

    }

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

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

//

EXPORT_C TArray<TPosLmItemId> CMnMapViewServiceBase::LinkedLandmarksToShow( TInt aDbIndex )

    {

    LOG1("CMnMapViewServiceBase::LinkedLandmarksToShow, db index %d", aDbIndex);

    if ( aDbIndex < 0 || aDbIndex >= iLinkedLandmarksLists.Count() )

        {

        PanicServer( KMnPanicArrayIndexOutOfBounds );

        }

    return iLinkedLandmarksLists[aDbIndex]->iLandmarkIds.Array();

    }

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

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

//

EXPORT_C TArray<const HBufC*> CMnMapViewServiceBase::LandmarksToShowDatabases()

    {

    LOG("CMnMapViewServiceBase::LandmarksToShowDatabases");

    if ( iTempDatabaseList.Count() != iLinkedLandmarksLists.Count() )

        {

        // update database list

        iTempDatabaseList.Reset();    

        for ( TInt i = 0; i < iLinkedLandmarksLists.Count(); i++ )

            {

            iTempDatabaseList.Append( iLinkedLandmarksLists[i]->iDatabaseUri );

            }

        }

    return iTempDatabaseList.Array();

    }

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

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

//

EXPORT_C TPtrC CMnMapViewServiceBase::SelectionRequestText()

    {

    LOG("CMnMapViewServiceBase::SelectionRequestText");

    return iSelectionRequestText->Des();

    }

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

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

//

EXPORT_C TBool CMnMapViewServiceBase::IsAreaCentralPointSet()

    {

    LOG("CMnMapViewServiceBase::IsAreaCentralPointSet");

    return !( Math::IsNaN( iCentralPoint.Latitude() ) &&

              Math::IsNaN( iCentralPoint.Longitude() ) );

    }

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

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

//

EXPORT_C void CMnMapViewServiceBase::GetAreaCentralPoint( TCoordinate& aCentralPoint )

    {

    LOG("CMnMapViewServiceBase::GetAreaCentralPoint");

    aCentralPoint = iCentralPoint;

    }

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

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

//

EXPORT_C TReal CMnMapViewServiceBase::AreaRadius()

    {

    LOG("CMnMapViewServiceBase::AreaRadius");

    return iRadius;

    }

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

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

//

EXPORT_C void CMnMapViewServiceBase::CompleteSelectionRequestL( const CPosLandmark& aLandmark )

    {

    LOG("CMnMapViewServiceBase::CompleteSelectionRequestL(free) in");

    if ( !IsAsyncRequestActive() )

        {

        PanicServer( KMnPanicAttemptToCompleteNoRequest );

        }

    if ( iOptions & CMnMapView::EOptionRestrictSelection )

        {

        User::Leave( KErrArgument );

        }

    CleanSelectionResult();

    iResultLandmark = PosLandmarkSerialization::PackL( aLandmark );

    TMnMapSelectionResultInfo info( *iResultLandmark );

    TPckgC<TMnMapSelectionResultInfo> resultInfoPack( info );

    TInt err = iMessage.Write( EMnIpcMapSelectionResultInfoParamIndex, resultInfoPack );

    CompleteRequest( err );

    LOG("CMnMapViewServiceBase::CompleteSelectionRequestL(free) out");

    }

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

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

//

EXPORT_C void CMnMapViewServiceBase::CompleteSelectionRequest( TInt aLandmarkIndex )

    {

    LOG1("CMnMapViewServiceBase::CompleteSelectionRequest(index) in, index=%d", aLandmarkIndex);

    if ( !IsAsyncRequestActive() )

        {

        PanicServer( KMnPanicAttemptToCompleteNoRequest );

        }

    if ( aLandmarkIndex < 0 || aLandmarkIndex >= iLandmarks.Count() )

        {

        PanicServer( KMnPanicArrayIndexOutOfBounds );

        }

    CleanSelectionResult();

    TMnMapSelectionResultInfo info( aLandmarkIndex );

    TPckgC<TMnMapSelectionResultInfo> resultInfoPack( info );

    TInt err = iMessage.Write( EMnIpcMapSelectionResultInfoParamIndex, resultInfoPack );

    CompleteRequest( err );

    LOG("CMnMapViewServiceBase::CompleteSelectionRequest(index) out");

    }

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

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

//

EXPORT_C void CMnMapViewServiceBase::CompleteSelectionRequest(

    TPosLmItemId aLandmarkId, 

    TInt aDbIndex)

    {

    LOG2("CMnMapViewServiceBase::CompleteSelectionRequest(id,db) in, dbIndex %d, lmId %d",

        aDbIndex, aLandmarkId);

    if ( !IsAsyncRequestActive() )

        {

        PanicServer( KMnPanicAttemptToCompleteNoRequest );

        }

    if ( aDbIndex < 0 || aDbIndex >= iLinkedLandmarksLists.Count() )

        {

        LOG1("CMnMapViewServiceBase::CompleteSelectionRequest(id,db) dbIndex invalid, max %d",

            iLinkedLandmarksLists.Count());

        PanicServer( KMnPanicArrayIndexOutOfBounds );

        }

    if ( KErrNotFound == iLinkedLandmarksLists[aDbIndex]->iLandmarkIds.Find( aLandmarkId ) )

        {

        LOG("CMnMapViewServiceBase::CompleteSelectionRequest(id,db) lmId not found");

        PanicServer( KMnPanicArrayIndexOutOfBounds );

        }

    CleanSelectionResult();

    TMnMapSelectionResultInfo info( 

        aLandmarkId, 

        *(iLinkedLandmarksLists[aDbIndex]->iDatabaseUri) );

    TPckgC<TMnMapSelectionResultInfo> resultInfoPack( info );

    TInt err = iMessage.Write( EMnIpcMapSelectionResultInfoParamIndex, resultInfoPack );

    CompleteRequest( err );

    LOG("CMnMapViewServiceBase::CompleteSelectionRequest(id,db) out");

    }

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

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

//

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

    {

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

    switch ( aMessage.Function() )

        {

        case EMnIpcAddLmIdsToShow:

            HandleAddLandmarkIdsToShowL( aMessage );

            break;

        case EMnIpcAddLandmarksToShow:

            HandleAddLandmarksToShowL( aMessage );

            break;

        case EMnIpcResetLandmarksToShow: // blind request

            ResetLandmarks();

            break;

        case EMnIpcCancel:

            HandleCancelRequestL( aMessage );

            break;

        case EMnIpcShowMap:

            UnpackOptionsL( aMessage );

		    LOG("CMnMapViewServiceBase::ServiceL, calling HandleShowMapL");

            HandleShowMapL();

            Complete( aMessage, KErrNone );

            break;

        case EMnIpcShowCurrentLocation:

            UnpackOptionsL( aMessage );

		    LOG("CMnMapViewServiceBase::ServiceL, calling HandleShowCurrentLocationL");

            HandleShowCurrentLocationL();

            Complete( aMessage, KErrNone );

            break;

        case EMnIpcInitRequestText:

            UnpackSelectionRequestTextL( aMessage );

            Complete( aMessage, KErrNone );

            break;

        case EMnIpcSelectFromMap:

            PrepareAsyncRequestL( aMessage );

            UnpackOptionsL( aMessage );

            UnpackSelectionRequestTextL( aMessage );

            VerifySelectionRequestL();

		    LOG("CMnMapViewServiceBase::ServiceL, calling HandleSelectFromMapL");

            HandleSelectFromMapL();

            break;

        case EMnIpcGetSelectionResultLandmark:

            HandleGetSelectionResultLandmarkL( aMessage );

            break;

        case EMnIpcGetSelectionResultDbUri:

            HandleGetSelectionResultDbUriL( aMessage );

            break;

        default:

            CMnServiceBase::ServiceL( aMessage );

        }

}

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

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

//

void CMnMapViewServiceBase::CleanSelectionResult()

    {

    delete iResultLandmark;

    iResultLandmark = NULL;

    }

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

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

//

void CMnMapViewServiceBase::HandleAddLandmarkIdsToShowL( const RMessage2& aMessage )

    {

    LOG("CMnMapViewServiceBase::HandleAddLandmarkIdsToShowL in");

    if ( IsAsyncRequestActive() )

        {

        User::Leave( KErrLocked );

        }

    // Read client's data

    HBufC* uri = CopyClientBufferLC( aMessage, EMnIpcMapDbUriParamIndex );

    HBufC8* buf = CopyClientBuffer8LC( aMessage, EMnIpcMapLmIdsParamIndex );

    if ( buf->Size() % ( sizeof( TPosLmItemId ) ) != 0 )

        {

        User::Leave( KErrArgument );

        }

    TInt lmCount = buf->Size() / ( sizeof( TPosLmItemId ) );

    const TPosLmItemId* ids = reinterpret_cast<const TPosLmItemId*>( buf->Ptr() );

    // Save data to internal structs

    iTempDatabaseList.Reset();        

    CLinkedLandmarksList* linked = NULL;

    // check if this database is already listed

    TInt dbIndex = FindDatabase( *uri );

    if ( dbIndex == KErrNotFound )

        {

        linked = new (ELeave) CLinkedLandmarksList;

        CleanupStack::PushL( linked );

        linked->iDatabaseUri = uri;

        iLinkedLandmarksLists.AppendL( linked );

        CleanupStack::Pop( linked );

        }

    else

        {

        linked = iLinkedLandmarksLists[dbIndex];

        }

    for ( TInt i = 0; i < lmCount; i++ )

        {

        linked->iLandmarkIds.AppendL( ids[i] );

        }

    // Finalize

    Complete( aMessage, KErrNone );

    CleanupStack::PopAndDestroy( buf );

    CleanupStack::Pop( uri );

    LOG("CMnMapViewServiceBase::HandleAddLandmarkIdsToShowL out");

    }

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

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

//

void CMnMapViewServiceBase::HandleAddLandmarksToShowL( const RMessage2& aMessage )

    {

    LOG("CMnMapViewServiceBase::HandleAddLandmarksToShowL in");

    if ( IsAsyncRequestActive() )

        {

        User::Leave( KErrLocked );

        }

    HBufC8* buf = CopyClientBuffer8LC( aMessage, EMnIpcMapLandmarksParamIndex );

    RDesReadStream readStream( *buf );

    LOG1("CMnMapViewServiceBase::HandleAddLandmarksToShowL buffersize %d", buf->Size());

    TInt lmCount = readStream.ReadInt32L();

    LOG1("CMnMapViewServiceBase::HandleAddLandmarksToShowL lmCount %d", lmCount);

    for ( TInt i = 0; i < lmCount; i++ )

        {

        TInt lmSize = readStream.ReadInt32L();

        HBufC8* lmBuf = HBufC8::NewLC( lmSize );

        TPtr8 lmData( lmBuf->Des() );

        readStream.ReadL( lmData, lmSize );

        CPosLandmark* lm = PosLandmarkSerialization::UnpackL( *lmBuf );

        CleanupStack::PushL( lm );

        iLandmarks.AppendL( lm );

        CleanupStack::Pop( lm );

        CleanupStack::PopAndDestroy( lmBuf );

        }

    readStream.Close();

    CleanupStack::PopAndDestroy( buf );

    Complete( aMessage, KErrNone );

    LOG("CMnMapViewServiceBase::HandleAddLandmarksToShowL out");

    }

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

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

//

void CMnMapViewServiceBase::HandleGetSelectionResultLandmarkL( const RMessage2& aMessage )

    {

    LOG("CMnMapViewServiceBase::HandleGetSelectionResultLandmarkL in");

    if ( iResultLandmark )

        {

        aMessage.WriteL( EMnIpcMapSelResultBufferParamIndex, *iResultLandmark );

        Complete( aMessage, KErrNone );

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    LOG("CMnMapViewServiceBase::HandleGetSelectionResultLandmarkL out");

    }

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

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

//

void CMnMapViewServiceBase::HandleGetSelectionResultDbUriL( const RMessage2& aMessage )

    {

    LOG("CMnMapViewServiceBase::HandleGetSelectionResultDbUriL in");

    __ASSERT_DEBUG( 

        iResultDbIndex >= 0 && iResultDbIndex < iLinkedLandmarksLists.Count() ,

        Panic( KErrGeneral ) );

    if ( iResultDbIndex != KErrNotFound )

        {

        __ASSERT_DEBUG( 

            iLinkedLandmarksLists[iResultDbIndex]->iDatabaseUri ,

            Panic( KErrGeneral ) );

        aMessage.WriteL( 

            EMnIpcMapSelResultBufferParamIndex, 

            *(iLinkedLandmarksLists[iResultDbIndex]->iDatabaseUri) );

        Complete( aMessage, KErrNone );

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    LOG("CMnMapViewServiceBase::HandleGetSelectionResultDbUriL out");

    }

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

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

//

void CMnMapViewServiceBase::ResetLandmarks()

    {

    if ( !IsAsyncRequestActive() )

        {

	    iLandmarks.ResetAndDestroy();

	    iLinkedLandmarksLists.ResetAndDestroy();

        }

    }

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

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

//

TInt CMnMapViewServiceBase::FindDatabase( const TDesC& aUri )

    {

    for ( TInt i = 0; i < iLinkedLandmarksLists.Count(); i++ )

        {

        CLinkedLandmarksList* list = iLinkedLandmarksLists[i];

        if ( list->iDatabaseUri->Compare( aUri ) == 0 )

            {

            return i;

            }

        }

    return KErrNotFound;

    }

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

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

//

void CMnMapViewServiceBase::UnpackOptionsL( const RMessage2& aMsg )