/*
* Copyright (c) 2004-2007 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:  Implements the CLandmarksPositionRequest class
*
*/



#include <AknWaitDialog.h>
#include <coemain.h>
#include <aknnotewrappers.h>

#include <lbspositioninfo.h>

#include <LmRefApp.rsg>
#include "LandmarksUtils.h"
#include "LandmarksPositionRequest.h"
#include "LandmarksOperationObserver.h"

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

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CLandmarksPositionRequest::CLandmarksPositionRequest(
    MLandmarksOperationObserver* aObserver)
    : 
    CActive(CActive::EPriorityStandard), 
    iObserver(aObserver),
    iState(EIdle)
    {
    CActiveScheduler::Add(this);
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CLandmarksPositionRequest::ConstructL(const TDesC& aAppName)
    {
    iAppName = aAppName.AllocL();
    InitializeL();
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CLandmarksPositionRequest* CLandmarksPositionRequest::NewL(
    const TDesC& aAppName,
    MLandmarksOperationObserver* aObserver)
    {
    CLandmarksPositionRequest* self =
        new (ELeave) CLandmarksPositionRequest(aObserver);
    CleanupStack::PushL(self);
    self->ConstructL(aAppName);
    CleanupStack::Pop(self);
    return self;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CLandmarksPositionRequest::~CLandmarksPositionRequest()
    {
    Cancel();
    iPositioner.Close();
    iLocationServer.Close();
    DismissWaitNote();
    delete iAppName;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CLandmarksPositionRequest::FetchPositionInfoL(
    const TDesC& aMessage,
    TPositionInfo& aPositionInfo)
    {
    Cancel();
    iPositionInfo = &aPositionInfo;

    // Initialize wait note
    CAknWaitDialog* waitNote = new (ELeave) CAknWaitDialog(
        reinterpret_cast <CEikDialog**> (&iWaitNote), ETrue); // show immedaitely
    CleanupStack::PushL(waitNote);
    waitNote->SetCallback(this);
    waitNote->SetTextL(aMessage);
    waitNote->PrepareLC(R_LMREFAPP_ACQUIRE_LOCATION_WAIT_NOTE);
    CleanupStack::Pop(waitNote); // waitNote will delete itself
    iWaitNote = waitNote;

    // Request location
    iState = EAcquiringDefaultLocation;
    ExecuteNextStep();

    // Launch wait note
    iWaitNote->RunLD();
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CLandmarksPositionRequest::DismissWaitNote()
    {
    if (iWaitNote)
        {
        TInt err;
        TRAP(err, iWaitNote->ProcessFinishedL());
        iWaitNote = NULL;
        }
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CLandmarksPositionRequest::DoCancel()
    {
    // Cancel location request
    if (iState == EAcquiringDefaultLocation)
        {
        iPositioner.CancelRequest(EPositionerNotifyPositionUpdate);
        }
    else if (iState == EAcquiringLastKnownLocation)
        {
        iPositioner.CancelRequest(EPositionerGetLastKnownPosition);
        }
    iState = EIdle;
    DismissWaitNote();
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CLandmarksPositionRequest::RunL()
    {
    if (iStatus == KErrNone)
        {
        // Location retrieved. Operation finished.

        if ( iState == EAcquiringLastKnownLocation )
            {
            // inform user that it was last known location
            HBufC* msg = CCoeEnv::Static()->AllocReadResourceLC( R_LMREFAPP_LAST_LOCATION_USED_INFO );
            LandmarksUtils::ErrorNoteL( *msg );
            CleanupStack::PopAndDestroy(msg);
            }

        NotifyOperationCompleteL(KErrNone);
        }
    else // iStatus != KErrNone
        {
        if (iState == EAcquiringDefaultLocation)
            {
            // Fetching current location failed. Try last known location.
            iState = EAcquiringLastKnownLocation;
            ExecuteNextStep();
            }
        else if (iState == EAcquiringLastKnownLocation)
            {
            // Fetching last known location failed. 
            NotifyOperationCompleteL(iStatus.Int());
            }
        }
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
TInt CLandmarksPositionRequest::RunError(TInt /*aError*/)
    {
    // Ignore possible errors.
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CLandmarksPositionRequest::DialogDismissedL(TInt aButtonId)
    {
    if (aButtonId == EAknSoftkeyCancel)
        {
        // Dialog is already dismissed by framework
        iWaitNote = NULL;

        Cancel();
        }
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CLandmarksPositionRequest::ShowErrorL(TInt aError)
    {
    HBufC* format = CCoeEnv::Static()->AllocReadResourceAsDes16LC(
        R_LMREFAPP_ACQUIRING_LOC_ERROR);
    
    // some extra characters needed for error code
    const TInt KErrorCodeTextLength = 10;
    HBufC* message = HBufC::NewLC(
        format->Length() + KErrorCodeTextLength);
    message->Des().Format(*format, aError);

    CAknInformationNote* informationNote = 
        new (ELeave) CAknInformationNote(ETrue);
    informationNote->ExecuteLD(*message);
    CleanupStack::PopAndDestroy(2, format);
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CLandmarksPositionRequest::ExecuteNextStep()
    {
    iStatus = KRequestPending;

    switch (iState)
        {
        case EAcquiringDefaultLocation:
            iPositioner.NotifyPositionUpdate(*iPositionInfo, iStatus);
            break;
        case EAcquiringLastKnownLocation:
            iPositioner.GetLastKnownPosition(*iPositionInfo, iStatus);
            break;
        default:    
            // this case should never happen, see RunL
            LandmarksUtils::Panic(KErrGeneral);
            break;
        }

    SetActive();
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CLandmarksPositionRequest::NotifyOperationCompleteL(TInt aError)
    {
    DismissWaitNote();
    iState = EIdle;

    // Notify user if location couldn't be fetched.
    if (aError) 
        {
        ShowErrorL(aError);
        }

    // Notify Observer
    iObserver->NotifyOperationProgressL(
        EAcquiringLocation, KOperationReady, aError);
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CLandmarksPositionRequest::InitializeL()
    {
    // Connect to the location server
    User::LeaveIfError(iLocationServer.Connect());

    // Open the default positioner
    User::LeaveIfError(iPositioner.Open(iLocationServer));

    // Set this application as location requestor
    User::LeaveIfError(iPositioner.SetRequestor(
        CRequestor::ERequestorService,
        CRequestor::EFormatApplication,
        *iAppName));

    // Set maximum allowed time for a location request
    const TInt K30Seconds = 30000000;
    TTimeIntervalMicroSeconds timeOut(K30Seconds);
    TPositionUpdateOptions updateOptions;
    updateOptions.SetUpdateTimeOut(timeOut);
    User::LeaveIfError(iPositioner.SetUpdateOptions(updateOptions));
    }