/*

* Copyright (c) 2007-2009 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: This file implements class CESMRCasPluginUiLauncher.

 *

*/

#include "emailtrace.h"

#include "cesmrcaspluginuilauncher.h"

#include "mesmrcaspluginuilauncherobserver.h"

#include "esmrinternaluid.h"

// <cmail> Profiler removed. </cmail>

#include <badesca.h>

//<cmail>

#include "tfsccontactactionpluginparams.h"

#include <cmrmailboxutils.h>

#include <calsession.h>

#include <calentry.h>

#include <caluser.h>

#include "mfscactionutils.h"

//</cmail>

#include <aknlists.h>

#include <utf.h>

#include <ecom/ecom.h>

#include "esmrcommands.h"

#include <esmrcasplugindata.rsg>

#include <aknnotewrappers.h>

// Unnamed namespace for local definitions and functions

namespace { // codescanner::namespace

#ifdef _DEBUG

    enum TPanic

        {

        EPanicIndexOOB = 1

        };

    void Panic( TPanic aPanic )

        {

        _LIT( KCntxt, "CESMRCasPluginUiLauncher" );

        User::Panic( KCntxt(), aPanic );

        }

#endif // _DEBUG

const TUint KMRSequenceNo( 0 );

const TInt KOneHour( 1 );

// Constants for rounding up MR start time

const TInt KMinuteRoundToHourStart( 46 );

const TInt KMinuteRoundToHourEnd( 15 );

const TInt KHourMinutes( 0 );

const TInt KHalfHourMinutes( 30 );

/**

 * Prompts user to select default mailbox.

 */

TInt PromptForDefaultMailboxL(

        RArray<CMRMailboxUtils::TMailboxInfo>& aMailBoxes )

    {

    FUNC_LOG;

    TInt selected( KErrCancel );

    TInt mbCount = aMailBoxes.Count();

    if( mbCount > 0)

        {

        CAknSinglePopupMenuStyleListBox* list =

            new (ELeave) CAknSinglePopupMenuStyleListBox;

        CleanupStack::PushL(list);

        CAknPopupList* popupList = CAknPopupList::NewL(

                                            list,

                                            R_AVKON_SOFTKEYS_OK_CANCEL);

        CleanupStack::PushL(popupList);

        list->ConstructL(popupList, CEikListBox::ELeftDownInViewRect);

        list->CreateScrollBarFrameL(ETrue);

        list->ScrollBarFrame()->SetScrollBarVisibilityL(

            CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto);

        CEikonEnv* eikEnv = CEikonEnv::Static();// codescanner::eikonenvstatic

        CDesCArrayFlat* items = new (ELeave)CDesCArrayFlat(mbCount);

        CleanupStack::PushL(items);

        for(TInt i=0; i<mbCount; ++i)

            {

            items->AppendL( aMailBoxes[i].iName );

            }

        CleanupStack::Pop(items);

        CTextListBoxModel* model = list->Model();

        //Pass ownersip of items to model

        model->SetItemTextArray(items);

        HBufC* title = KNullDesC().AllocLC();

        popupList->SetTitleL(*title);

        CleanupStack::PopAndDestroy(title);

        TBool accepted = popupList->ExecuteLD();

        CleanupStack::Pop( popupList );

        if(accepted)

            {

            selected = list->CurrentItemIndex();

            }

        else

            {

            selected = KErrCancel;

            }

        CleanupStack::PopAndDestroy( list );

        }

    else

        {

        //No mailboxes defined.  Could prompt user to define one here.

        selected = KErrCancel;

        }

    return selected;

    }

/**

 * Fetches the supported mailboxes.

 * @param aMBUtils utils class

 * @param aMailBoxes to test

 */

void SupportedMailboxesL(

        CMRMailboxUtils& aMBUtils,

        RArray<CMRMailboxUtils::TMailboxInfo>& aMailBoxes )

    {

    FUNC_LOG;

    aMBUtils.ListMailBoxesL( aMailBoxes );

    RImplInfoPtrArrayOwn implArray;

    CleanupClosePushL( implArray );

    //Get all MRViewers Implementation

    const TUid mrViewersIface = TUid::Uid(KMRViewersInterfaceUID);

    REComSession::ListImplementationsL(mrViewersIface, implArray );

    TInt mrviewerCount( implArray.Count() );

    TInt index(0);

    TInt mailboxCount( aMailBoxes.Count() );

    while ( index < mailboxCount )

         {

         TBool supported( EFalse );

         for ( TInt i(0); (i < mrviewerCount) && !supported; ++ i )

             {

             TBuf16<KMaxUidName> mbName;

             CnvUtfConverter::ConvertToUnicodeFromUtf8(

                     mbName,

                     implArray[i]->DataType() );

             __ASSERT_DEBUG( aMailBoxes.Count() > index, Panic( EPanicIndexOOB ) );

             if( aMailBoxes[index].iMtmUid.Name().CompareF(mbName) == 0)

                  {

                  supported = ETrue;

                 }

             }

         if ( supported )

             {

             index++;

             }

         else

             {

             aMailBoxes.Remove( index );

             mailboxCount = aMailBoxes.Count();

             }

         }

    CleanupStack::PopAndDestroy( &implArray );

    }

}//namespace

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

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

// CESMRCasPluginUiLauncher::CESMRCasPluginUiLauncher

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

//

inline CESMRCasPluginUiLauncher::CESMRCasPluginUiLauncher(

        CCalSession& aCalSession,

        CCalenInterimUtils2& aCalUtils,

        CMRMailboxUtils& aMBUtils,

        const TFscContactActionPluginParams& aParams,

        MESMRCasPluginUiLauncherObserver& aExecuteObserver )

:   iInParams(

            TUid::Uid( KUidCalendarApplication ),

            aCalSession,

            MAgnEntryUi::ECreateNewEntry ),

    iCalSession( aCalSession ),

    iParams( aParams ),

    iCalUtils( aCalUtils ),

    iMBUtils( aMBUtils ),

    iExecuteObserver( aExecuteObserver )

    {

    FUNC_LOG;

    iInParams.iMsgSession = NULL;

    iInParams.iSpare = 0;

    }

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

// CESMRCasPluginUiLauncher::~CESMRCasPluginUiLauncher

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

//

CESMRCasPluginUiLauncher::~CESMRCasPluginUiLauncher()

    {

    FUNC_LOG;

    delete iMtmUid;

    delete iCalEntry;

    }

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

// CESMRCasPluginUiLauncher::NewL

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

//

CESMRCasPluginUiLauncher* CESMRCasPluginUiLauncher::NewL(

        CCalSession& aCalSession,

        CCalenInterimUtils2& aCalUtils,

        CMRMailboxUtils& aMBUtils,

        const TFscContactActionPluginParams& aParams,

        MESMRCasPluginUiLauncherObserver& aExecuteObserver )

    {

    FUNC_LOG;

    CESMRCasPluginUiLauncher* self =

            new (ELeave ) CESMRCasPluginUiLauncher(

                    aCalSession,

                    aCalUtils,

                    aMBUtils,

                    aParams,

                    aExecuteObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CESMRCasPluginUiLauncher::ConstructL

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

//

void CESMRCasPluginUiLauncher::ConstructL()

    {

    FUNC_LOG;

    //nothing to do here

    }

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

// CESMRCasPluginUiLauncher::LaunchMeetingRequestViewL

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

//

void CESMRCasPluginUiLauncher::LaunchMeetingRequestViewL(

        const RPointerArray<CCalUser>& aAttendees  )

    {

    FUNC_LOG;

    HBufC8* guidBuf = iCalUtils.GlobalUidL();

    CleanupStack::PushL( guidBuf );

    delete iCalEntry; iCalEntry = NULL;

    iCalEntry = CCalEntry::NewL(

                    CCalEntry::EAppt,

                    guidBuf,

                    CCalEntry::EMethodRequest,

                    KMRSequenceNo );

    CleanupStack::Pop (guidBuf ); // Ownership is transferred

    AddOrganizerL();

    AddAttendeesL( aAttendees );

    SetStartAndEndTimeL();

    // Launch Entry UI

    RPointerArray<CCalEntry> entries;

    CleanupClosePushL ( entries );

    entries.AppendL( iCalEntry );

    MAgnEntryUi* editorsPlugin =  NULL;

    if ( iCalUtils.MRViewersEnabledL( ETrue ) )

        {

        //CAgnEntryUi resolves Meeting request viewer based on mtm uid

        TBuf8<KMaxUidName> mrMtm;

        CnvUtfConverter::ConvertFromUnicodeToUtf8(

                mrMtm,

                *iMtmUid );

        editorsPlugin = CAgnEntryUi::NewL( mrMtm );

        CleanupDeletePushL(editorsPlugin );

        }

    else

        {

        // MR is not supported --> Leave

        User::Leave (KErrNotSupported );

        }

    editorsPlugin->ExecuteViewL( entries, iInParams, iOutParams, *this );

    if (iOutParams.iAction == MAgnEntryUi::EMeetingSaved)

    	{

    	TInt res = R_FS_MR_NOTE_SAVED;

        CAknConfirmationNote* dialog = new( ELeave )CAknConfirmationNote();

        dialog->ExecuteLD( *prompt );

        CleanupStack::PopAndDestroy( prompt );

    	}

    CleanupStack::PopAndDestroy( editorsPlugin );

    CleanupStack::PopAndDestroy( &entries );

    }

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

// CESMRCasPluginUiLauncher::ProcessCommandL

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

//

void CESMRCasPluginUiLauncher::ProcessCommandL(

        TInt aCommandId )

    {

    FUNC_LOG;

    ProcessCommandWithResultL( aCommandId );

    }

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

// CESMRCasPluginUiLauncher::ProcessCommandWithResultL

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

//

TInt CESMRCasPluginUiLauncher::ProcessCommandWithResultL(

        TInt aCommandId )

    {

    FUNC_LOG;

    if ( aCommandId == EESMRCmdEditorInitializationComplete )

        {

        iExecuteObserver.MREditorInitializationComplete();

        }

    return KErrNone;

    }

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

// CESMRCasPluginUiLauncher::IsCommandAvailable

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

//

TBool CESMRCasPluginUiLauncher::IsCommandAvailable(

        TInt aCommandId )

    {

    FUNC_LOG;

    TBool retVal = EFalse;

    if ( aCommandId == EESMRCmdEditorInitializationComplete )

        {

        retVal = ETrue;

        }

    return retVal;

    }

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

// CESMRCasPluginUiLauncher::AddOrganizerL

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

//

void CESMRCasPluginUiLauncher::AddOrganizerL()

    {

    FUNC_LOG;

    CMRMailboxUtils::TMailboxInfo defaultMailBox;

    delete iMtmUid; iMtmUid = NULL;

    iMtmUid = defaultMailBox.iMtmUid.Name().AllocL();

    //Set the organizer from the selected mailbox

    CCalUser* organizer = CCalUser::NewL( defaultMailBox.iEmailAddress );

    CleanupStack::PushL(organizer );

    iCalEntry->SetOrganizerL(organizer );

    CleanupStack::Pop( organizer ); // Ownership trasferred

    }

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

// CESMRCasPluginUiLauncher::AddAttendeesL

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

//

void CESMRCasPluginUiLauncher::AddAttendeesL(

        const RPointerArray<CCalUser>& aAttendees   )

    {

    FUNC_LOG;

    //Add attendees from contact set

    TInt attendeeCount( aAttendees.Count() );

    for (TInt i=0; i < attendeeCount; ++i )

        {

        CCalAttendee* attendee = CCalAttendee::NewL( aAttendees[i]->Address() );

        CleanupStack::PushL( attendee );

        attendee->SetCommonNameL( aAttendees[i]->CommonName() );

        attendee->SetRoleL( CCalAttendee::EReqParticipant );

        iCalEntry->AddAttendeeL( attendee );

        CleanupStack::Pop( attendee );

        }

    }

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

// CESMRCasPluginUiLauncher::SetStartAndEndTimeL

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

//

void CESMRCasPluginUiLauncher::SetStartAndEndTimeL()

    {

    FUNC_LOG;

    // Adjust start time to future

    TTime start;

    start.UniversalTime();

    start = start + TTimeIntervalMinutes( KHalfHourMinutes );

    // Round up start time. 

    // Minutes between 46 ... 15 ==> 00

    // Minutes between 16 ... 45 ==> 30

    TDateTime currentTime = start.DateTime();

    TInt minute( currentTime.Minute() );

    if ( minute >= KMinuteRoundToHourStart || 

         minute <= KMinuteRoundToHourEnd   )

        {

        // Rounding to hour

        currentTime.SetMinute( KHourMinutes );

        }

    else

        {

        currentTime.SetMinute( KHalfHourMinutes );

        }

    start = currentTime;

    TTime end = start + TTimeIntervalHours( KOneHour );

    TCalTime startCalTime;

    startCalTime.SetTimeUtcL( start );

    TCalTime endCalTime;

    endCalTime.SetTimeUtcL( end );

    iCalEntry->SetStartAndEndTimeL( startCalTime, endCalTime );

    // Set time for input parameters

    TUint8 timemode = iCalEntry->StartTimeL().TimeMode ( );

    if (timemode == TCalTime::EFloating )

        {

        iInParams.iInstanceDate.SetTimeLocalFloatingL( start );

        }

    else

        {

        iInParams.iInstanceDate.SetTimeUtcL (start );

        }

    }

// EOF