/*

 * Copyright (c) 2010 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:  Verifier plug-in which derives from CPosPrivacyNotifier.

 *

 */

// INCLUDE FILES

#include "lpdverifierplugin.h"

#include "lpdrequestao.h"

#include "lpdrequestorprocessor.h"

#include "lpdverifierquerylauncher.h"

#include "lpdnotifierquerylauncher.h"

#include "locverifierdlgdebug.h"

#include "locutilsdebug.h"

#include <eiknotapi.h>

#include <lbs/epos_rposrequestorstack.h>

#include <epos_csuplsettingsconstants.h>

// INCLUDE FILES

#include <s32mem.h>

const TInt KPrivSrvSecureId = 0x10281D45;

// CONSTANTS

// Unnamed namespace for local definitions

const MEikSrvNotifierBase2::TNotifierPriority KNotifierPriority =

        MEikSrvNotifierBase2::ENotifierPriorityHigh;

const TUid KNotifierChannel =

    {

    0x100065ac

    };

#ifdef _DEBUG

_LIT( KPanicText, "CLpdVerifierPlugin" );

enum TPanicCode

    {

    KLpdErrGeneral = 1

    };

#endif

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

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

// CLpdVerifierPlugin::CLpdVerifierPlugin

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CLpdVerifierPlugin::CLpdVerifierPlugin() :

    iCurrentRequest(KPosNullQNRequestId)

    {

    }

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

// CLpdVerifierPlugin::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CLpdVerifierPlugin::ConstructL()

    {

    LOCVERIFIERDLGDEBUG( "+CLpdVerifierPlugin::ConstructL" );

    BaseConstructL(KNotifierChannel, KNotifierPriority);

    iRtorProcessor = CLpdRequestorProcessor::NewL();

    LOCVERIFIERDLGDEBUG( "-CLpdVerifierPlugin::ConstructL" );    	

    }

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

// CLpdVerifierPlugin::NewL

// Two-phased constructor.

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

//

CLpdVerifierPlugin* CLpdVerifierPlugin::NewL()

    {

     LOCVERIFIERDLGDEBUG( "+CLpdVerifierPlugin::NewL" );

    CLpdVerifierPlugin* self = new (ELeave) CLpdVerifierPlugin;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

     LOCVERIFIERDLGDEBUG( "-CLpdVerifierPlugin::NewL" );

    return self;

    }

// Destructor

CLpdVerifierPlugin::~CLpdVerifierPlugin()

    {

    LOCVERIFIERDLGDEBUG( "+CLpdVerifierPlugin::~CLpdVerifierPlugin" );

    // Destruction of this plugin should only occur only in shutdown

    // or in severe problem situation.

    // A very special scenario is that base class construction leaves and

    // this destructor is called. In that case CompleteAllRequests() causes

    // access violation (noticed this by checking source code of base class).

    if (NotifierBase())

        { // base class has been fully constructed, method call is safe

        CompleteAllRequests(KErrGeneral);

        }

    // It is enough to delete queries so when don't get callbacks.

    FreeQueryResources();

    delete iRequestActiveObject;

    iRequestActiveObject = NULL; 

    delete iRtorProcessor;

    iRtorProcessor = NULL; 

    LOCVERIFIERDLGDEBUG( "-CLpdVerifierPlugin::~CLpdVerifierPlugin" );

    }

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

// CLpdVerifierPlugin::HandleNewRequestL

// (other items were commented in a header).

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

//

void CLpdVerifierPlugin::HandleNewRequestL(TPosQNRequestId /*aRequestId */ )

    {

    LOCVERIFIERDLGDEBUG( "+CLpdVerifierPlugin::HandleNewRequestL" );

    // Check whether the notifier is already handling a request

    // If yes, do nothing for now.

    if (iRequestActiveObject)

        {

        return;

        }

    else

        {

        iRequestActiveObject = CLpdRequestAO::NewL(*this);

        iRequestActiveObject->ScheduleRequest();

        }

    LOCVERIFIERDLGDEBUG( "-CLpdVerifierPlugin::HandleNewRequestL" );

    }

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

// CLpdVerifierPlugin::HandleRequestCancelled

// (other items were commented in a header).

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

//

void CLpdVerifierPlugin::HandleRequestCancelled(TPosQNRequestId aRequestId)

    {

    LOCVERIFIERDLGDEBUG( "+CLpdVerifierPlugin::HandleRequestCancelled" );

    // Check whether the request is coming from Uikon Server. 

    // If not reject this request.

    if (!CheckClientSecureId(KPrivSrvSecureId))

        {

        return;

        }

    if (aRequestId != iCurrentRequest)

        {

        return;

        }

    if (iCurrentRequestType == EQuery)

        { // Verification was cancelled

        __ASSERT_DEBUG( iVerifierQuery, HandleDebugAssertError() );

        LOCVERIFIERDLGDEBUG( "Verification cancelled" );

        iVerifierQuery->Cancel();

        }

    else

        {

        // It must be a notification then, this case is not probable but

        // we can cancel the dialog if this would happen.

        __ASSERT_DEBUG( iCurrentRequestType == ENotification,

                HandleDebugAssertError() );

         __ASSERT_DEBUG( iNotifier, HandleDebugAssertError() );

        LOCVERIFIERDLGDEBUG( "Notification cancelled" );

        iNotifier->Cancel();

        }

    LOCVERIFIERDLGDEBUG( "-CLpdVerifierPlugin::HandleRequestCancelled" );

    }

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

// CLpdVerifierPlugin::HandleAllRequestCancelled

// (other items were commented in a header).

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

//

void CLpdVerifierPlugin::HandleAllRequestCancelled()

    {

    LOCVERIFIERDLGDEBUG( "+CLpdVerifierPlugin::HandleAllRequestCancelled" );

    if (iCurrentRequest != KPosNullQNRequestId)

        { // current request requires some specific behavior

        HandleRequestCancelled(iCurrentRequest);

        }

   LOCVERIFIERDLGDEBUG( "-CLpdVerifierPlugin::HandleAllRequestCancelled" );

    }

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

// CLpdVerifierPlugin::HandleVerificationResultL

// (other items were commented in a header).

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

//

void CLpdVerifierPlugin::HandleVerificationResultL(TInt aResultCode)

    {

    iVerifyResult = aResultCode;

        LOCVERIFIERDLGDEBUG1( "+CLpdVerifierPlugin::HandleVerificationResultL(%d)",

                iVerifyResult );

    switch (iVerifyResult)

        {

        case KErrNone: // fall through

        case KErrAccessDenied:

            {

            // No need for rules now in 3.0

            break;

            }

        case KErrTimedOut:

            { // UI's internal timer expired

            break;

            }

        case KErrCancel:

            {

            return; // don't handle next req. yet

            }

        case KErrAbort: // This is used for emergency call support

            {

            CompleteAllRequests(iVerifyResult);

            // ScheduleRequest() allows the current call chain

            // run to completion and resources are released after that.

            iRequestActiveObject->ScheduleRequest();

            return;

            }

        default:

            {

            break;

            }

        }

    CompleteCurrentAndContinue(iVerifyResult); // this request was handled

    LOCVERIFIERDLGDEBUG( "-CLpdVerifierPlugin::HandleVerificationResultL" );

    }

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

// CLpdVerifierPlugin::HandleNotificationResultL

// (other items were commented in a header).

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

//

void CLpdVerifierPlugin::HandleNotificationResultL(TInt aResultCode)

    {

   LOCVERIFIERDLGDEBUG1( "+CLpdVerifierPlugin::HandleVerificationResultL(%d)",

                aResultCode );

    CompleteRequest(iCurrentRequest, aResultCode);

    iCurrentRequest = KPosNullQNRequestId;

    switch (aResultCode)

        {

        case KErrNone: // fall through

        case KErrTimedOut: // fall through

            {

            break;

            }

        case KErrCancel:

            {

            break;

            }

        case KErrAbort: // This is used for emergency call support

            {

            CompleteAllRequests(aResultCode);

            // ScheduleRequest() -> allows the current call chain

            // run to completion and resources are released after that.

            break;

            }

        default:

            {

            break;

            }

        }

    iRequestActiveObject->ScheduleRequest(); // handle next req.

    LOCVERIFIERDLGDEBUG( "-CLpdVerifierPlugin::HandleNotificationResultL" );

    }

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

// CLpdVerifierPlugin::HandleLeave

// (other items were commented in a header).

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

//

void CLpdVerifierPlugin::HandleLeave(TInt /*aError*/)

    {

        LOCVERIFIERDLGDEBUG1( "+CLpdVerifierPlugin::HandleLeave(%d)", aError);

    // In this case user needs feedback about the error situation:

    // In case of leave current request is completed with

    // iVerifyResult, but queue handling is still continued.

    // iVerifyResult is better completion code for request than aError.

    CompleteCurrentAndContinue(iVerifyResult);

    LOCVERIFIERDLGDEBUG( "-CLpdVerifierPlugin::HandleLeave" );

    }

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

// CLpdVerifierPlugin::HandleNextRequest

// (other items were commented in a header).

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

//

void CLpdVerifierPlugin::HandleNextRequest()

    {

    LOCVERIFIERDLGDEBUG( "+CLpdVerifierPlugin::HandleNextRequest" );

    TRAPD( err, HandleNextRequestL() );

    if (err)

        {

        // In case of leave current request is completed with

        // error code, but queue handling is still continued.

        // If we couldn't start handling the request it is

        // better not to confuse user with an error note.

        CompleteCurrentAndContinue(iVerifyResult);

        }

    LOCVERIFIERDLGDEBUG( "-CLpdVerifierPlugin::HandleNextRequest" );

    }

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

// CLpdVerifierPlugin::HandleNextRequestL

// (other items were commented in a header).

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

//

void CLpdVerifierPlugin::HandleNextRequestL()

    {

    LOCVERIFIERDLGDEBUG( "+CLpdVerifierPlugin::HandleNextRequestL" );

    // It is better to free previous query resources here, because

    // now all callback methods have finished (active object allowed

    // run to completion)

    this->FreeQueryResources();

    // Read the next request:

    RArray<TPosQNRequestId> requests;

    CleanupClosePushL(requests);

    GetRequestsL(requests);

    if (requests.Count() == 0)

        { // No more requests to handle

        CleanupStack::PopAndDestroy(); // requests

        // This is a very important step, it allows new requests

        // to flow in ( see HandleNewRequestL() ):

        delete iRequestActiveObject;

        iRequestActiveObject = NULL;

        return;

        }

    iCurrentRequest = requests[0];

    CleanupStack::PopAndDestroy(); // requests

    SetCurrentRequestL(iCurrentRequest);

    // Check whether the request is coming from Uikon Server. If not reject this request.

    if (!CheckClientSecureId(KPrivSrvSecureId))

        {

        CompleteCurrentAndContinue(KErrPermissionDenied);

        return;

        }

    // Check the request type

    iCurrentRequestType = RequestTypeL(iCurrentRequest);

    iRtorProcessor->ReadRequestorsL(*this);

    if (iCurrentRequestType == EQuery)

        {

        LOCVERIFIERDLGDEBUG( "New verification request received" );

        HandleNextVerificationL();

        }

    else if (iCurrentRequestType == ENotification)

        {

        LOCVERIFIERDLGDEBUG( "New notification request received" );

        HandleNextNotificationL();

        }

    else

        {

        User::Leave(KErrNotSupported);

        }

    LOCVERIFIERDLGDEBUG( "-CLpdVerifierPlugin::HandleNextRequestL" );

    }

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

// CLpdVerifierPlugin::HandleNextVerificationL

// (other items were commented in a header).

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

//

void CLpdVerifierPlugin::HandleNextVerificationL()

    {

    LOCVERIFIERDLGDEBUG( "+CLpdVerifierPlugin::HandleNextVerificationL" );

    __ASSERT_DEBUG( iCurrentRequest != KPosNullQNRequestId,

            HandleAssertErrorL() );

    __ASSERT_DEBUG( !iVerifierQuery, HandleAssertErrorL() );

    CPosRequestor::TRequestType reqType;

       if (CheckRequestTypeL() == CPosRequestor::ERequestPeriodic)

            reqType = CPosRequestor::ERequestPeriodic;

        else

            reqType = CPosRequestor::ERequestSingleShot;

    TPosRequestSource source(RequestSource());

    if (source == EPosRequestSourceNotAvailable)

        {

        CompleteCurrentAndContinue(KErrNone);

        }

    else

        {

         TPosRequestDecision decision(QueryTimeoutStrategy());

        iRtorProcessor->iRequestType=reqType;

        iRtorProcessor->iRequestDecision=decision;

        iRtorProcessor->iDialogType=CLpdRequestorProcessor::EQuery;

        iVerifierQuery = CLpdVerifierQueryLauncher::NewL(*this);

        // Ownership NOT transferred

        iVerifierQuery->SetRequestInfoL(iRtorProcessor);

        iVerifierQuery->StartQueryL();    

        }

    LOCVERIFIERDLGDEBUG( "-CLpdVerifierPlugin::HandleNextVerificationL" );

    }

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

// CLpdVerifierPlugin::HandleNextNotificationL

// (other items were commented in a header).

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

//

void CLpdVerifierPlugin::HandleNextNotificationL()

    {

    LOCVERIFIERDLGDEBUG( "+CLpdVerifierPlugin::HandleNextNotificationL" );

    __ASSERT_DEBUG( iCurrentRequest != KPosNullQNRequestId,

            HandleAssertErrorL() );

    // There is no differentiation now for periodic and single shot notifications

    HandleNextNonPeriodicNotificationL();

    LOCVERIFIERDLGDEBUG( "-CLpdVerifierPlugin::HandleNextNotificationL" );

    }

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

// CLpdVerifierPlugin::HandleNextNonPeriodicNotificationL

// (other items were commented in a header).

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

//

void CLpdVerifierPlugin::HandleNextNonPeriodicNotificationL()

    {

    LOCVERIFIERDLGDEBUG( "+CLpdVerifierPlugin::HandleNextNonPeriodicNotificationL" );

    __ASSERT_DEBUG( iCurrentRequest != KPosNullQNRequestId,

            HandleAssertErrorL() );

    __ASSERT_DEBUG( !iNotifier, HandleAssertErrorL() );

    if (RequestSource() != EPosRequestSourceNetwork)

        { // Notifications are supported only for network requests

        User::Leave(KErrNotSupported);

        }

    TPosNotificationReason reason = NotificationReason();

    TPosRequestDecision decision = LocationRequestDecision();

    iRtorProcessor->iNotifReason=reason;

    iRtorProcessor->iDialogType=CLpdRequestorProcessor::ENotification;

    iRtorProcessor->iRequestDecision=decision;

    iNotifier = CLpdNotifierQueryLauncher::NewL(*this);

    iNotifier->SetRequestInfoL(iRtorProcessor);

    iNotifier->StartQueryL();

    LOCVERIFIERDLGDEBUG( "-CLpdVerifierPlugin::HandleNextNonPeriodicNotificationL" );

    }

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

// CLpdVerifierPlugin::CompleteCurrentAndContinue

// (other items were commented in a header).

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

//

void CLpdVerifierPlugin::CompleteCurrentAndContinue(TInt aResultCode)

    {

    LOCVERIFIERDLGDEBUG( "+CLpdVerifierPlugin::CompleteCurrentAndContinue" );

    if (iCurrentRequest != KPosNullQNRequestId)

        {

        CompleteRequest(iCurrentRequest, aResultCode);

        }

    iCurrentRequest = KPosNullQNRequestId;

    __ASSERT_DEBUG( iRequestActiveObject, HandleDebugAssertError() );

    iRequestActiveObject->ScheduleRequest(); // handle next req.

    LOCVERIFIERDLGDEBUG( "-CLpdVerifierPlugin::CompleteCurrentAndContinue" );

    }

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

// CLpdVerifierPlugin::FreeQueryResources

// (other items were commented in a header).

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

//

void CLpdVerifierPlugin::FreeQueryResources()

    {

    LOCVERIFIERDLGDEBUG( "+CLpdVerifierPlugin::FreeQueryResources" );

    iCurrentRequest = KPosNullQNRequestId;

    delete iVerifierQuery;

    iVerifierQuery = NULL;

    iVerifyResult = KErrGeneral;

    delete iNotifier;

    iNotifier = NULL;

    if (iRtorProcessor)

        { // if already construction fails iRtorProcessor may

        // be NULL, otherwise it points to an instance.

        iRtorProcessor->ResetAndDestroyRequestors();

        }

    LOCVERIFIERDLGDEBUG( "-CLpdVerifierPlugin::FreeQueryResources" );

    }

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

// CLpdVerifierPlugin::HandleAssertErrorL

// (other items were commented in a header).

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