/*

 * Copyright (c) 2002 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 <eikenv.h>

#include <eiknotapi.h>

#include <AknIconArray.h>

#include <apgcli.h>

#include <lbs/epos_rposrequestorstack.h>

#include <epos_csuplsettingsconstants.h>

#include <StringLoader.h>

#include <locverifierdlg.rsg>

#include "lpdverifierplugin.h"

#include "lpdrequestao.h"

#include "lpdrequestorprocessor.h"

#include "lpdverifierquerylauncher.h"

#include "lpdnotifierquerylauncher.h"

#include "lpdbasemodel.h"

#include "locconsts.h"

#include "locverifierdlgdebug.h"

#include "locfileutils.h"

#include "locrequestorutilsresolver.h"

#include "lpdperiodicprocessor.h"

// INCLUDE FILES

#include <s32mem.h>

#include "locphonenumberformat.h"

#include "locverifiercoverui.h"

// CONSTANTS

// The Increment size for the package buffer used for packing the descriptors

const TInt KReqBufferIncrSize = 256;

const TInt KLpdItemArrayGranularity = 50;

const TInt KNonPeriodicRequest = 0;

const TInt KPeriodicRequest = 1;

const TInt KNotifyMessageLength = 300;

// CONSTANTS

// Unnamed namespace for local definitions

const MEikSrvNotifierBase2::TNotifierPriority KNotifierPriority =

        MEikSrvNotifierBase2::ENotifierPriorityHigh;

const TUid KNotifierChannel =

    {

    0x100065ac

    };

_LIT_SECURE_ID(KUikonSrvSecureId,0x10003a4a);

#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), iPeriodicNotQue(

            KLpdItemArrayGranularity)

    {

    iEnv = CEikonEnv::Static();

    }

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

// CLpdVerifierPlugin::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CLpdVerifierPlugin::ConstructL()

    {

    BaseConstructL(KNotifierChannel, KNotifierPriority);

    TFileName* resourceFile = new (ELeave) TFileName;

    CleanupStack::PushL(resourceFile);

    // these appends are always safe:

    resourceFile->Append(KLocNotifierRscPath);

    resourceFile->Append(KLocVerifierRscFileName);

    TFileName* dllDrive = new (ELeave) TFileName;

    CleanupStack::PushL(dllDrive);

    Dll::FileName(*dllDrive);

    LocFileUtils::GetNearestLanguageFileL(iEnv->FsSession(), *dllDrive,

            *resourceFile);

    CleanupStack::PopAndDestroy(dllDrive);

    iResourceOffset = iEnv->AddResourceFileL(*resourceFile);

    CleanupStack::PopAndDestroy(resourceFile);

    iRtorProcessor = CLpdRequestorProcessor::NewL();

    iPeriodicProcessor = CLpdPeriodicProcessor::NewL( *this );

    }

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

// CLpdVerifierPlugin::NewL

// Two-phased constructor.

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

//

CLpdVerifierPlugin* CLpdVerifierPlugin::NewL()

    {

    CLpdVerifierPlugin* self = new (ELeave) CLpdVerifierPlugin;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

// Destructor

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();

    iPeriodicNotQue.Close();

    delete iPeriodicProcessor;

    delete iRequestActiveObject;

    delete iRtorProcessor;

    iEnv->DeleteResourceFile(iResourceOffset);

    }

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

// CLpdVerifierPlugin::HandleNewRequestL

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

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

//

void CLpdVerifierPlugin::HandleNewRequestL(TPosQNRequestId aRequestId)

    {

    EnqueIfPeriodicL(aRequestId);

    // 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();

        }

    }

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

// CLpdVerifierPlugin::EnqueIfPeriodicL

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

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

//

void CLpdVerifierPlugin::EnqueIfPeriodicL(TPosQNRequestId aRequestId)

    {

    SetCurrentRequestL(aRequestId);

    TRequestType requestType = RequestTypeL(aRequestId);

    CPosRequestor::TRequestType requestorType = CheckRequestTypeL();

    if (requestType == ENotification && requestorType

            == CPosRequestor::ERequestPeriodic)

        {

        TInt64 sessionId = -1;

        GetSessionIdL( sessionId );

        TLpdPeriodicReqInfo newReq(aRequestId, sessionId);

        if (iPeriodicProcessor)

            {

            if (iPeriodicProcessor->GetSessionId() == sessionId)

                {

                CompleteRequest(aRequestId, KErrNone);

                }

            return;

            }

        else

            {

            TIdentityRelation<TLpdPeriodicReqInfo> matcher(

                    TLpdPeriodicReqInfo::MatchSession);

            TInt index = iPeriodicNotQue.Find(newReq, matcher);

            // Remove if it was present in Que

            if (index == KErrNotFound)

                {

                iPeriodicNotQue.Append(newReq);

                }

            else

                {

                CompleteRequest(aRequestId, KErrNone);

                }

            }

        }

    if (KPosNullQNRequestId != iCurrentRequest)

        SetCurrentRequestL(iCurrentRequest);

    }

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

// CLpdVerifierPlugin::HandleRequestCancelled

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

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

//

void CLpdVerifierPlugin::HandleRequestCancelled(TPosQNRequestId aRequestId)

    {

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

    // If not reject this request.

    if (!CheckClientSecureId(KUikonSrvSecureId))

        {

        return;

        }

    // This method is called for Verification Query Cancellation.

    // There are 2 scenarios when the cancellation can come.

    // 1. The verification query for which the cancellation is done is 

    //         currently is running

    // 2. The verification query is not running currently but is in the 

    //         requests Queue maintained by the base class.

    //

    // Case 1 :

    //		

    // If there is a Verification query currently running and the requestId

    //         matches then the cancel notificaiton has to be popped up.

    //

    // Case 2 :

    //		

    //     1. A Verification query was popped up.

    //     2. The network timed out and sent a cancel request which popped 

    //           up a notification request.

    //     3. The network sends another verification query in the mean time

    //           and also cancels it. The resulting notification dialog will

    //           not be run since there is still a notification that has not

    //           been dismissed by the user.

    //

    // Hence in case 2 the notification information is maintained in a Que 

    // in the iRequestActiveObject. Once the current notification dialog 

    // closes and there are no more verification dialogs pending, the 

    // notification dialogs are run one after the other.

    if (aRequestId != iCurrentRequest)

        {

        if (aRequestId == KPosNullQNRequestId)

            {

            return;

            }

        //Put this new Notification Request on the queue and then process

        //it later from iRequestActiveObject(CLpdRequestAO class) RunL.		

        RPosRequestorStack* requestors = NULL;

            TRAP_IGNORE(

                    SetCurrentRequestL(aRequestId);

                    // requestors is allocated in iRtorProcessor and ownership is finally

                    // transferred to iRequestActiveObject.

                    requestors = iRtorProcessor->RetrieveRequestorsL( *this );

                    // Enqueue the request to iRequestActiveObject

                    iRequestActiveObject->EnqueueRequestL(RequestSource(),

                            CancelReason(),

                            QueryTimeoutStrategy(),

                            requestors););

        return;

        }

    iCancelInfo.iCancelled = ETrue;

    iCancelInfo.iReason = CancelReason();

    iCancelInfo.iDecision = QueryTimeoutStrategy();

    iCancelInfo.iSource = RequestSource();

    if (iCurrentRequestType == EQuery)

        { // Verification was cancelled

        __ASSERT_DEBUG( iVerifierQuery, HandleDebugAssertError() );

        __ASSERT_DEBUG( !iNotifier, HandleDebugAssertError() );

        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( !iVerifierQuery, HandleDebugAssertError() );

        __ASSERT_DEBUG( iNotifier, HandleDebugAssertError() );

        iNotifier->Cancel();

        }

    }

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

// CLpdVerifierPlugin::HandleAllRequestCancelled

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

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

//

void CLpdVerifierPlugin::HandleAllRequestCancelled()

    {

    if (iCurrentRequest != KPosNullQNRequestId)

        { // current request requires some specific behavior

        HandleRequestCancelled(iCurrentRequest);

        }

    // Note that ScheduleRequest in the end of HandleRequestCancelled() allows

    // current call chain run to completion and resources are released after

    // that. Pending requests have been completed so they won't be processed.

    }

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

// 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:

            {

            __ASSERT_DEBUG( iCancelInfo.iCancelled, HandleAssertErrorL() );

            NotifyCancellationL(iCancelInfo.iSource, iCancelInfo.iReason,

                    iCancelInfo.iDecision);

            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:

            {

            iEnv->HandleError(iVerifyResult);

            break;

            }

        }

    CompleteCurrentAndContinue(iVerifyResult); // this request was handled

    }

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

// CLpdVerifierPlugin::HandleNotificationResultL

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

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

//

void CLpdVerifierPlugin::HandleNotificationResultL(TInt aResultCode)

    {

    TLpdPeriodicReqInfo newReq(iCurrentRequest, -1);

    TIdentityRelation<TLpdPeriodicReqInfo> matcher(

            TLpdPeriodicReqInfo::MatchPrivacy);

    TInt index = iPeriodicNotQue.Find(newReq, matcher);

    // Remove if it was present in Que

    if (index != KErrNotFound)

        {

        iPeriodicNotQue.Remove(index);

        }

    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:

            {

            iEnv->HandleError(aResultCode);

            break;

            }

        }

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

    }

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

// 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:

    iEnv->HandleError(aError);

    // 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);

    }

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

// CLpdVerifierPlugin::HandleNextRequest

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

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

//

void 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);

        }

    }

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

// CLpdVerifierPlugin::HandleNextRequestL

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

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

//

void 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(KUikonSrvSecureId))

        {

        CompleteCurrentAndContinue(KErrPermissionDenied);

        return;

        }

    // Check the request type

    iCurrentRequestType = RequestTypeL(iCurrentRequest);

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

            && (iCurrentRequestType == ENotification))

        iRtorProcessor->SetRequestType(KPeriodicRequest);

    else

        iRtorProcessor->SetRequestType(KNonPeriodicRequest);

    iRtorProcessor->ReadRequestorsL(*this);

    if (iCurrentRequestType == EQuery)

        {

        HandleNextVerificationL();

        }

    else if (iCurrentRequestType == ENotification)

        {

        HandleNextNotificationL();

        }

    else

        {

        User::Leave(KErrNotSupported);

        }

    }

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

// CLpdVerifierPlugin::HandleNextVerificationL

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

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