/*

* 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: Extended functinality for policy provision process.

*

*/

#include <cmmanagerext.h>

#include <cmconnectionmethodext.h>

#include <cmdestinationext.h>

#include <cmconnectionmethoddef.h>

#include <centralrepository.h>

#include "sit.h"

#include "extender.h"

#include "log.h"

#include "vpnconnstarter.h"

#include "extenderhelper.h"

CExtender* CExtender::NewL()

    {

    LOG(Log::Printf(_L("CExtender::NewL - begin\n")));

    CExtender* self = new (ELeave) CExtender();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(); // self

    LOG(Log::Printf(_L("CExtender::NewL - end\n")));

    return self;

    }

CExtender::~CExtender()

    {

    LOG(Log::Printf(_L("CExtender::~CExtender\n")));

    Cancel();

    iVpnExtServ.Close();

    iNotifier.Close();

    delete iExtenderHelper;

    }

CExtender::CExtender() : CActive(EPriorityNormal)

    {

    }

void CExtender::ConstructL()

    {

    CActiveScheduler::Add(this);    

    User::LeaveIfError(iVpnExtServ.Connect());

    User::LeaveIfError(iNotifier.Connect());

    }

void CExtender::DoCancel()

    {

    CancelOngoingOperation();

    }

void CExtender::RunL()

    {

     ChangeStateL();

    }

void CExtender::GotoState(TInt aState)

    {

    SetNextState(aState);

    SetActive();

    TRequestStatus* status = &iStatus;

    User::RequestComplete(status, KErrNone);

    }

void CExtender::SetCurrState(TInt aState)

    {

    iCurrState = aState;

    }

void CExtender::SetNextState(TInt aState)

    {

    iNextState = aState;

    }

TInt CExtender::CurrState()

    {

    return iCurrState;

    }

TInt CExtender::NextState()

    {

    return iNextState;

    }

TInt CExtender::RunError(TInt aError)

    {

    LOG(Log::Printf(_L("CExtender::RunError - error = %d\n"), aError));

    ProcessComplete(aError);

    return KErrNone;

    }

void CExtender::ChangeStateL()

    {

    switch (NextState())

        {

        case KStateCheckPolicyUpdateAvailability:

            StateCheckPolicyUpdateAvailabilityL();

            break;

        case KStateAfterAskUpdateConfirmation:

            StateAfterAskUpdateConfirmationL();

            break;

        case KStateUpdatePolicy:

            StateUpdatePolicyL();

            break;

        case KStateAfterUpdatePolicy:

            StateAfterUpdatePolicyL();

            break;

        case KStateShowUpdateCompleteNote:

            StateShowUpdateCompleteNote();

            break;

        case KStateAfterShowUpdateCompleteNote:

            StateAfterShowUpdateCompleteNote();

            break;

        case KStateShowApActFailureNote:

            StateShowApActFailureNote();

            break;

        case KStateAfterShowApActFailureNote:

            StateAfterShowApActFailureNote();

            break;

        default:

            User::Panic(KSitName, EPanicInvalidTaskHandlerState);

        }   

    }

void CExtender::CancelOngoingOperation()

    {

    switch (CurrState())

        {

        case KStateShowApActFailureNote:

        case KStateAskUpdateConfirmation:

        case KStateShowUpdateCompleteNote:

            LOG(Log::Printf(_L("CExtender::CancelOngoingOperation - cancelling notifier\n")));

            iNotifier.CancelNotifier(KUidVpnDialogNotifier);

            break;

        case KStateCheckPolicyUpdateAvailability:

        case KStateUpdatePolicy:

        case KStateAfterUpdatePolicy:    

            LOG(Log::Printf(_L("CExtender::CancelOngoingOperation - cancelling Policy Provision operation\n")));

            iVpnExtServ.CancelPolicyProvision();

            iExtenderHelper->Cancel();

            break;

        case KStateAfterShowApActFailureNote:

        case KStateAfterAskUpdateConfirmation:

        case KStateAfterCheckPolicyUpdateAvailability:

        case KStateAfterShowUpdateCompleteNote:

            LOG(Log::Printf(_L("CExtender::CancelOngoingOperation - cancelling nothing\n")));

            // Nothing to cancel

            break;

        default:

            User::Panic(KSitName, EPanicInvalidTaskHandlerState);

        }

    }

void CExtender::OnVpnApActStart(CVpnConnStarter* aVpnConnStarter)

    {

    LOG(Log::Printf(_L("CExtender::OnVpnApActStart\n")));

    iVpnConnStarter = aVpnConnStarter;

    // Prevent the deletion of the iVpnConnStarter task

    // handler (that owns us) as long as we are running

    iVpnConnStarter->SetDelayedTaskEnd(ETrue);

    }

void CExtender::OnVpnApActCancel()

    {

    LOG(Log::Printf(_L("CExtender::OnVpnApActCancel\n")));

    // Allow the deletion of the iVpnConnStarter task handler

    // (the activation has been cancelled in which case

    // automatic policy updating process will not be

    // performed and thus the task handler can be deleted

    // right away after cancel)

    iVpnConnStarter->SetDelayedTaskEnd(EFalse);

    }

void CExtender::OnVpnApActEnd(const TVpnPolicyId* aPolicyId, TInt aStatus, TUint32 aRealIapId)

    {

    LOG(Log::Printf(_L("CExtender::OnVpnApActEnd\n")));

    iPolicyId.Copy(*aPolicyId);

    iRealIapId = aRealIapId;

    iVpnActStatus = aStatus;

    if (iVpnActStatus != KErrNone && iVpnActStatus != KErrCancel)

        {

        // Report the failure to the system

        // (management session runner if such is present)

        // First show a VPN connection activation failure note

        GotoState(KStateShowApActFailureNote);

        }

    else if (iVpnActStatus == KErrCancel)

        {

        // The user has cancelled the VPN connection activation,

        // in that case the automatic policy update operation is

        // not performed

        EndTask();

        }

    else

        {

        // Begin the combined policy update and

        // certificate enrollment process right away

        //GotoState(KStateCheckPolicyUpdateAvailability);

        EndTask();

        }

    }

void CExtender::StateShowApActFailureNote()

    {

    LOG(Log::Printf(_L("CExtender::StateShowApActFailureNote\n")));

    SetCurrState(KStateShowApActFailureNote);

    iStatus = KRequestPending;

    SetActive();

    TRequestStatus* ownStatus = &iStatus;

    User::RequestComplete(ownStatus, KErrNone);

    SetNextState(KStateAfterShowApActFailureNote);

    }

void CExtender::StateAfterShowApActFailureNote()

    {

    LOG(Log::Printf(_L("CExtender::StateAfterShowApActFailureNote\n")));

    SetCurrState(KStateAfterShowApActFailureNote);

    iNotifier.CancelNotifier(KUidVpnDialogNotifier);

    // Begin the combined policy update

    // and certificate enrollment process

    GotoState(KStateCheckPolicyUpdateAvailability);

    }

void CExtender::StateCheckPolicyUpdateAvailabilityL()

    {

    LOG(Log::Printf(_L("CExtender::StateCheckPolicyUpdateAvailabilityL\n")));

    SetCurrState(KStateCheckPolicyUpdateAvailability);

    LOG(Log::Printf(_L(" Doing the policy update.\n")));

    TAgileProvisionPolicy vpnPolicyName;

    User::LeaveIfError(iVpnExtServ.GetPolicyName(vpnPolicyName));

    if ( iPolicyId.Compare(vpnPolicyName.iPolicyName) == 0 )

       {

        SetCurrState(KStateAskUpdateConfirmation);

        TVpnDialogInfo dialogInfo(TVpnDialog::EPolicyUpdateConfirmation, 0);

        iDialogInfoDes() = dialogInfo;

        iNotifier.StartNotifierAndGetResponse(iStatus, KUidVpnDialogNotifier,

                                             iDialogInfoDes, iDialogResponseDes);

        SetActive();

        SetNextState(KStateAfterAskUpdateConfirmation);

        }

    else

        {

        EndTask();

        }

    }

void CExtender::StateAfterAskUpdateConfirmationL()

    {

    LOG(Log::Printf(_L("CExtender::StateAfterAskUpdateConfirmationL\n")));        

    SetCurrState(KStateAfterAskUpdateConfirmation);

    iNotifier.CancelNotifier(KUidVpnDialogNotifier);

    // If the user pressed Cancel or an

    // error occurred, we stop here

    User::LeaveIfError(iStatus.Int());

    iShowCompletionNote = ETrue;

    GotoState(KStateUpdatePolicy);

    }

void CExtender::StateUpdatePolicyL()

    {

    LOG(Log::Printf(_L("CExtender::StateUpdatePolicy\n")));

    SetCurrState(KStateUpdatePolicy);

   if ( iExtenderHelper == NULL)

       iExtenderHelper=CExtenderHelper::NewL();

    iExtenderHelper->StartNotifierL(this);

    iVpnExtServ.SynchronizePolicyServer(iStatus);

    SetActive();

    SetNextState(KStateAfterUpdatePolicy);

    }

void CExtender::StateAfterUpdatePolicyL()

    {

    LOG(Log::Printf(_L("CExtender::StateAfterUpdatePolicyL\n")));    

    if (iStatus != KErrNone)

        {

        User::Leave(iStatus.Int());

        }

    ProcessComplete(KErrNone);

    }

void CExtender::ProcessComplete(TInt aStatus)

    {

    LOG(Log::Printf(_L("CExtender::ProcessComplete - status = %d\n"), aStatus));        

    iFinalStatus = aStatus;

    GotoState(KStateShowUpdateCompleteNote);

    }

void CExtender::StateShowUpdateCompleteNote()

    {

    LOG(Log::Printf(_L("CExtender::StateShowUpdateCompleteNote\n")));    

    SetCurrState(KStateShowUpdateCompleteNote);

    if (!iShowCompletionNote || iFinalStatus == KErrCancel)

        {

         EndTask();

        }

    else if ( iFinalStatus == KErrNone )

        {

        TVpnDialogInfo dialogInfo(TNoteDialog::EInfo, TVpnNoteDialog::EPolicyUpdateSucceeded);

                                iDialogInfoDes() = dialogInfo;

        iNotifier.StartNotifierAndGetResponse(iStatus, KUidVpnDialogNotifier,

                                           iDialogInfoDes, iDialogResponseDes);

        SetActive();

        SetNextState(KStateAfterShowUpdateCompleteNote);

        }

    else

        {

        TVpnDialogInfo dialogInfo(TNoteDialog::EInfo, TVpnNoteDialog::EPolicyUpdateFailed);

                iDialogInfoDes() = dialogInfo;

        iNotifier.StartNotifierAndGetResponse(iStatus, KUidVpnDialogNotifier,

                                          iDialogInfoDes, iDialogResponseDes);

        SetActive();

        SetNextState(KStateAfterShowUpdateCompleteNote);

        }

    }

void CExtender::StateAfterShowUpdateCompleteNote()

    {

    LOG(Log::Printf(_L("CExtender::StateAfterShowUpdateCompleteNote\n")));    

    SetCurrState(KStateAfterShowUpdateCompleteNote);

    iNotifier.CancelNotifier(KUidVpnDialogNotifier);

    EndTask();

    }

TCmSettingSelection CExtender::GetPolicyServerSelectionL()

    {

   // Get policy server details

    // from the Policy Provision server configuration

    TAgileProvisionApiServerSettings vpnPolicyServerDetails;

    User::LeaveIfError(iVpnExtServ.ServerDetails(vpnPolicyServerDetails));

    // Return the server selection

    return vpnPolicyServerDetails.iSelection;

    }

void CExtender::EndTask()

    {

    LOG(Log::Printf(_L("CExtender::EndTask\n")));    

    // Allow the deletion of the CVpnConStarter task handler

    iVpnConnStarter->SetDelayedTaskEnd(EFalse);

    // We're done and the enclosing connection starter

    // object is now free to go (causing the deletion

    // of this extender object as well)

    iVpnConnStarter->TaskDone();

    }