/*

* 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:  ESMR esmviewer controller implementation

*

*/

// INCLUDE FILES

//<cmail>

#include "emailtrace.h"

#include "cesmrpolicy.h"

#include "esmrdef.h"

#include "cesmrpolicymanager.h"

//</cmail>

#include "cesmrviewerctrl.h"

#include "mesmrmeetingrequestentry.h"

#include "mesmrtaskextension.h"

#include "cesmruifactory.h"

#include "mesmruibase.h"

#include "tesmrinputparams.h"

#include "esmrconfig.hrh"

#include "cesmrconfirmationquery.h"

#include "cesmrutils.h"

#include "cesmrcaluserutil.h"

// Logging utilities

// From System

//<cmail>

#include "esmrutilsapiext.h"

//</cmail>

#include <msvstd.h>

#include <msvids.h>

//<cmail>

#include "FreestyleEmailUiConstants.h"

//</cmail>

#include <eikappui.h>

#include <eikenv.h>

// CONSTANTS

/// Unnamed namespace for local definitions

namespace { // codescanner::namespace

#if defined(_DEBUG)

// Definition for MR VIEWER ctrl panic text

_LIT(KMRViewerCtrlPanicTxt, "ESMRViewerCtrl" );

// MR VIEWER ctrl panic codes

enum TMRViewerCtrlPanicCode

    {

    EESMRViewerCtrlSyncher = 0, // Syncher is not created,

    EESMRViewerCtrlProcessor,

    EESMRViewerCtrlTaskExt,

    EESMRViewerCtrlPolicyMgr,

    };

void Panic(TMRViewerCtrlPanicCode aPanicCode)

    {

    User::Panic( KMRViewerCtrlPanicTxt, aPanicCode );

    }

#endif

/**

 */

    {

        {

            {

            }

        }

    }

}  // namespace

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

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

// CESMRViewerController::CESMRViewerController

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

// might leave.

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

//

CESMRViewerController::CESMRViewerController(

    RPointerArray<CCalEntry>& aEntries,

    const MAgnEntryUi::TAgnEntryUiInParams& aParams,

    MAgnEntryUi::TAgnEntryUiOutParams& aOutParams,

    MAgnEntryUiCallback& aCallback )

    : iInParams( aParams ),

      iOutParams( aOutParams ),

      iCallback( aCallback ),

      iEntries( aEntries )

    {

    FUNC_LOG;

    }

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

// CESMRViewerController::~CESMRViewerController

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

//

EXPORT_C CESMRViewerController::~CESMRViewerController()

    {

    delete iCtrlSyncher;

    delete iGuiFactory;

    }

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

// CESMRViewerController::NewL

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

//

EXPORT_C CESMRViewerController* CESMRViewerController::NewL(

    const TDesC8& aMtmuid,

    RPointerArray<CCalEntry>& aEntries,

    const MAgnEntryUi::TAgnEntryUiInParams& aParams,

    MAgnEntryUi::TAgnEntryUiOutParams& aOutParams,

    MAgnEntryUiCallback& aCallback )

    {

    FUNC_LOG;

    CESMRViewerController* self =

        new( ELeave ) CESMRViewerController( aEntries,

                                             aParams,

                                             aOutParams,

                                             aCallback );

    CleanupStack::PushL( self );

    self->ConstructL(aMtmuid);

    CleanupStack::Pop( self );

    return self;

    }

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

// CESMRViewerController::ConstructL

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

//

void CESMRViewerController::ConstructL(const TDesC8& /*aMtmUid */)

    {

    FUNC_LOG;

    // This will create ESMR UTILS. Initialization is asynchronous.

    // Competion is signaled via CESMRViewerController::HandleCalEngStatus.

    iESMRUtils = CESMRUtils::NewL( *this );

    iESMRUtils->SessionSetupL(

            iInParams.iCalSession,

            iInParams.iMsgSession );

    iGuiFactory = CESMRUiFactory::NewL();

    }

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

// CESMRViewerController::ExecuteL

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

//

EXPORT_C void CESMRViewerController::ExecuteL()

    {

    FUNC_LOG;

    iExecutionError = KErrNone;

    // Initialization waiter is needed because MR VIEWER user expects

    // MR VIEWER operation to be synchronous.

    iCtrlSyncher = new (ELeave) CActiveSchedulerWait;

    // MR UTILS calls CESMRViewerController::HandleCalEngStatus after init is

    // complete. CESMRViewerController::HandleCalEngStatus also sets

    // iExectionError if there occurs error during MR UTILS init.

    iCtrlSyncher->Start();

    User::LeaveIfError( iExecutionError );

    iEntryProcessor =

                iESMRUtils->ExtensionL(

                        TUid::Uid(KESMRMREntryProcessorUid) ) );

    iPolicyMgr =

        static_cast<CESMRPolicyManager*>(

                iESMRUtils->ExtensionL(

                        TUid::Uid(KESMRPolicyMgrUid) ) );

    iTaskExt =

        static_cast<MESMRTaskExtension*>(

                iESMRUtils->ExtensionL(

                        TUid::Uid(KESMRTaskExtensionUid) ) );

    // Check that all extensions are found

    if ( !iEntryProcessor || !iPolicyMgr || !iTaskExt )

        {

        // All extensions are not found --> Leave

        User::Leave( KErrNotSupported );

        }

    iEntryProcessor->ProcessL(

            &iInParams,

            &iEntries );

    LaunchCorrectOperationModeL();

    }

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

// CESMRViewerController::IsCommandAvailable

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

//

TBool CESMRViewerController::IsCommandAvailable( TInt aCommandId )

    {

    FUNC_LOG;

    TBool retValue( EFalse );

    if ( KFSEmailUiUid == iInParams.iCallingApp )

        {

        retValue = iCallback.IsCommandAvailable( aCommandId );

        }

    return retValue;

    }

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

// CESMRViewerController::ProcessCommandWithResultL

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

//

TInt CESMRViewerController::ProcessCommandWithResultL( TInt aCommandId )

    {

    FUNC_LOG;

    TInt result = ProcessCommandWithResultInternalL(aCommandId);

    return result;

    }

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

// CESMRViewerController::ProcessCommandL

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

//

void CESMRViewerController::ProcessCommandL( TInt aCommandId )

    {

    FUNC_LOG;

    ProcessCommandWithResultL( aCommandId );

    }

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

// CESMRViewerController::HandleCalEngStatus

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

//

void CESMRViewerController::HandleCalEngStatus( TMRUtilsCalEngStatus aStatus )

    {

    FUNC_LOG;

    __ASSERT_DEBUG( iCtrlSyncher, Panic(EESMRViewerCtrlSyncher) );

    if ( ENotReady == aStatus )

        {

        // cal db is not ready

        iExecutionError = KErrNotReady;

        }

    else if (ENotAvailable == aStatus )

        {

        // cal db cannot be found

        iExecutionError = KErrNotFound;

        }

// <cmail>

    if ( iCtrlSyncher &&

            iCtrlSyncher->IsStarted() &&

            iCtrlSyncher->CanStopNow() )

// </cmail>

        {

        // Exection continues in CESMRViewerController::ExecuteL

        iCtrlSyncher->AsyncStop();

        }

    }

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

// CESMRViewerController::HandleOperation

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

//

void CESMRViewerController::HandleOperation(

        TInt /*aType*/,

        TInt /*aPercentageCompleted*/,

        TInt /*aStatus*/ )

    {

    FUNC_LOG;

    }

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

// CESMRViewerController::ProcessCommandWithResultInternalL

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

//

TInt CESMRViewerController::ProcessCommandWithResultInternalL(

        TInt aCommandId )

    {

    FUNC_LOG;

    TESMRCommand command = static_cast<TESMRCommand>(aCommandId);

    TBool needToProcessOutputParams( ETrue );