/*

* Copyright (c) 2007 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:  ?Description

 *

*/

//debug

#include "calendarui_debug.h"

// INCLUDE FILES

#include <aknViewAppUi.h>               // CAknViewAppUi

#include <calenagendautils.h>

#include <calinstanceview.h>

#include <calencontext.h>

#include <caleninstanceid.h>            // TCalenInstanceId

#include <calenactionuiutils.h>

#include <aknappui.h>

#include "calenviewmanager.h"

#include "calencmdlinelauncher.h"

#include "calencontroller.h"            // CCalenController

#include "calencmdlineparser.h"         // CCalCmdLineParser

#include "CalenUid.h"

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

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

// CCalenCmdLineLauncher::CCalenCmdLineLauncher

// C++ default constructor

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

// Status : Draft/Proposal/Approved

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

//

CCalenCmdLineLauncher::CCalenCmdLineLauncher( CCalenController& aController,

                                                                    CAknViewAppUi& aAppUi )

    : iController( aController ), iAppUi( aAppUi )

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

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

// CCalenCmdLineLauncher::NewL

// 1st phase of construction

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

// Status : Draft/Proposal/Approved

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

//

CCalenCmdLineLauncher* CCalenCmdLineLauncher::NewL( CCalenController& aController,

                                                                              CAknViewAppUi& aAppUi )

    {

    TRACE_ENTRY_POINT;

    CCalenCmdLineLauncher* self = new( ELeave ) CCalenCmdLineLauncher( aController, aAppUi );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    TRACE_EXIT_POINT;

    return self;

    }

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

// CCalenCmdLineLauncher::~CCalenCmdLineLauncher

// Destructor

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

// Status : Draft/Proposal/Approved

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

//

CCalenCmdLineLauncher::~CCalenCmdLineLauncher()

    {

    TRACE_ENTRY_POINT;

    iController.CancelNotifications( this );

    if( iGlobalData )

        {

        iGlobalData->Release();

        }

    delete iCalendarLaunchCallBack;

    TRACE_EXIT_POINT;

    }

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

// CCalenCmdLineLauncher::ConstructL

// 2nd phase of construction

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

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

//

void CCalenCmdLineLauncher::ConstructL()

    {

    TRACE_ENTRY_POINT;

    // get the global data

    iGlobalData = CCalenGlobalData::InstanceL();

    RArray<TCalenNotification> exitFlags;

    exitFlags.Append(ECalenNotifyEntryDeleted);

    exitFlags.Append(ECalenNotifyInstanceDeleted);

    exitFlags.Append(ECalenNotifyDialogClosed);

    exitFlags.Append(ECalenNotifyEntryClosed);

    iController.RegisterForNotificationsL( this, exitFlags );

    exitFlags.Reset();

    TRACE_EXIT_POINT;

    }

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

// CCalenCmdLineLauncher::ProcessCommandParametersL

// takes care of commandline parameter.

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

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

//

TBool CCalenCmdLineLauncher::ProcessCommandParametersL( 

                                                                    TApaCommand /*aCommand*/,

                                                                    TFileName& /*aDocumentName*/,

                                                                    const TDesC8& aTail )

    {

    TRACE_ENTRY_POINT;

    // If aTail is set, other app starts Calendar

    if( aTail.Length() )

        {

        // If we are displaying a dialog, then Calendar is obviously already open

        // If we have been launched with cmd line parameters, we need to close the

        // open dialog and deal with the command line.  An example of this would be that

        // Calendar is in the background with an open entry editor, and is then launched from

        // the command line to open a new entry editor.  We need to close the old editor

        // using the same 'try and save whatever we can' logic that is used on a forced close

        // and then open the new editor.  We also have to prevent the focus state being updated

        // and highlighting the old entry in the day view.

        while( AppUi().IsDisplayingDialog() )

            {

            iIsExitOnDlgClose = EFalse;

            // Tell the editui that whatever it was doing, it should not alter

            // the focus state

            iController.IssueCommandL( ECalenNotifyFocusChange );

            // Send a key event to the currently open dialog (viewer / editor)

            // to dismiss it

            TKeyEvent key;

            key.iRepeats = 0;

            key.iCode = EKeyEscape;

            key.iModifiers = 0;

            CCoeEnv::Static()->SimulateKeyEventL( key, EEventKey );

            }

        // Interpret 8bit data as 16bit unicode data

        //lint -e{826} Disable the lint warning of the pointer sizes being different

        const TText* buf = reinterpret_cast<const TText*>(aTail.Ptr());

        TPtrC ptr(buf, aTail.Length() / (TInt) sizeof(TText));

        // create cmd line parser

        CCalenCmdLineParser* parser = CCalenCmdLineParser::NewL();

        CleanupStack::PushL( parser );

        // parse parameters

        parser->ParseCommandLineL( ptr );

        iCmdParameters = parser->CommandLineParameters();

        CleanupStack::PopAndDestroy(); // parser

        }

    // If we are launched to a specific view, find and activate it.

    // Any other launch types are handled in CalendarLaunchCallBack

    TBool useLaunchCallback = EFalse;

    MCalenContext &context = iGlobalData->Context();

    // If aUseViewerIfAvailable is ETrue then start activate Event view else Editor.

    TBool aUseViewerIfAvailable = EFalse;

    // If time variable is set we will use that as context time.

    TBool focusOnTime = iCmdParameters.iTime != Time::NullTTime() &&

                        iCmdParameters.iTime.Int64() !=  0 ; // for some reason 0 is now coming through as a null

                                                   // time during normal app start. perhaps it just hasn't been set.

    TCalTime focusTime;

    if( focusOnTime )

        {

        focusTime.SetTimeUtcL( iCmdParameters.iTime );

        }

    else

        {

        focusTime = context.DefaultCalTimeForViewsL();

        }

    switch( iCmdParameters.iCommandType )

        {

        case CCalenCmdLineParser::EStartTypeDate: 

        case CCalenCmdLineParser::EStartTypeDay:  

        case CCalenCmdLineParser::EStartTypeToday:

        case CCalenCmdLineParser::EStartTypeToDo:

        case CCalenCmdLineParser::EStartTypeWeek:

        case CCalenCmdLineParser::EStartTypeMonth:	

            {

            TInt command( 0 );

            TUid viewUid = TUid::Null();

            switch( iCmdParameters.iCommandType )

                {

                case CCalenCmdLineParser::EStartTypeDate: 

                case CCalenCmdLineParser::EStartTypeDay:  

                case CCalenCmdLineParser::EStartTypeToday:

                    {

                    command = ECalenDayView;

                    viewUid = KUidCalenDayView;

                    }

                    break;

                case CCalenCmdLineParser::EStartTypeToDo:

                    {

                    command = ECalenTodoView;

                    viewUid = KUidCalenTodoView;

                    }

                    break;

                case CCalenCmdLineParser::EStartTypeWeek:

                    {

                    command = ECalenWeekView;

                    viewUid = KUidCalenWeekView;

                    }

                    break;

                case CCalenCmdLineParser::EStartTypeMonth:

                    {

                    command = ECalenMonthView;

                    viewUid = KUidCalenMonthView;

                    }

                    break;             

                default:

                    {

                    ASSERT( 0 );

                    }

                }                     	

          	  context.SetFocusDateAndTimeL( focusTime,

                                         TVwsViewId( KUidCalendar, viewUid ) );

            if( iController.ViewManager().ViewsActivated() )

                {

                iController.IssueCommandL( command );

                }

            else

                {

                iController.ViewManager().ActivateDefaultViewL( viewUid );

                }

            }

            break;

        case CCalenCmdLineParser::EStartTypeUid:

        case CCalenCmdLineParser::EStartTypeUidViewer:

        case CCalenCmdLineParser::EStartTypeUidAlarmViewer:

        case CCalenCmdLineParser::EStartTypeUidAlarmViewerNoSnooze:

	        {

	        aUseViewerIfAvailable = ETrue;

	        iIsExitOnDlgClose = ETrue;

	        // Set context using local uid before launching this entry in the Event view or Editor 	       

            SetContextBeforeLaunchL();  

            if (aUseViewerIfAvailable

#ifdef RD_NO_EDIT_REPEATING_TODO_DAYNOTE    

    			 || iForceUseViewer

#endif // RD_NO_EDIT_REPEATING_TODO_DAYNOTE

        		)

        		{

		        if( iCmdParameters.iCommandType == CCalenCmdLineParser::EStartTypeUidAlarmViewer )

              		{

              		if(! iController.ViewManager().ViewsActivated() )                    

                        {

                        iController.ViewManager().ActivateDefaultViewL( KUidCalenEventView); 

                        }

                        // start in alarm viewer mode

                        iController.IssueCommandL( ECalenEventViewFromAlarm );

                    }

                else if( iCmdParameters.iCommandType == CCalenCmdLineParser::EStartTypeUidAlarmViewerNoSnooze )

                    {

                    if(! iController.ViewManager().ViewsActivated() )                    

                        {

                        iController.ViewManager().ActivateDefaultViewL( KUidCalenEventView);   

                        }                    

                    // start in alarm viewer mode (snooze key not available)

                    iController.IssueCommandL(  ECalenEventViewFromAlarmStopOnly );

                    }

                	// Activate the Event view 

                else 

                    {  

                    if( iController.ViewManager().ViewsActivated() )                    

                        {

                        iController.IssueCommandL( ECalenEventView );

                        }

                    else

                        {

                        iController.ViewManager().ActivateDefaultViewL( KUidCalenEventView);

                        }

                    }

		        }

		    else

		        {

		        iController.IssueCommandL( ECalenEditCurrentEntry );

		        } 

		    }

            break;          

        case CCalenCmdLineParser::EStartTypeNewMeeting:

        case CCalenCmdLineParser::EStartTypeNewMeetingRequest:

        case CCalenCmdLineParser::EStartTypeNewAnniv:

        case CCalenCmdLineParser::EStartTypeNewTodo:

            {

            // Activate the day view but send calendar to the background.  This handles the

            // case of a command line launch to a non existent entry uid.

            // A side effect of this is we will get an unwanted view activation notification

            // which we need to ignore.

            // See also StartEditorL and HandleViewActivation

            context.SetFocusDateAndTimeL( focusTime,

                                          TVwsViewId( KUidCalendar, KUidCalenDayView ) );

            if(!( iController.ViewManager().ViewsActivated()) )

                {

                iController.ViewManager().ActivateDefaultViewL( KUidCalenDayView );

                }

            CEikonEnv::Static()->RootWin().SetOrdinalPosition( -1, 0 );                

            useLaunchCallback = ETrue;

            } 

            break;

        default:  // Launched from app list

            {

            context.SetFocusDateAndTimeL( focusTime,

                                          TVwsViewId( KUidCalendar, KUidCalenMonthView /*uid*/ ) );

            useLaunchCallback = ETrue;

            break;

            }

        }

    if( useLaunchCallback )

        {

        // Issue the callback

        if( !iCalendarLaunchCallBack )

            {

            TCallBack callback( StaticCalendarLaunchCallBack, this );

            iCalendarLaunchCallBack = new( ELeave ) CAsyncCallBack( callback, 

                                                                                    CActive::EPriorityStandard );

            }

            // otherwise issue the callback immediately

            iCalendarLaunchCallBack->CallBack();

        }

    TRACE_EXIT_POINT;

    return ETrue;

    }

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

// CCalenCmdLineLauncher::StaticCalendarLaunchCallBack

// Called from processcommand parameters using CAsyncCallBack

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

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

//

TInt CCalenCmdLineLauncher::StaticCalendarLaunchCallBack( TAny* aObject )

    {

    TRACE_ENTRY_POINT;

    CCalenCmdLineLauncher* thisPtr( static_cast<CCalenCmdLineLauncher*>( aObject ) );

    TRACE_EXIT_POINT;

    return thisPtr->CalendarLaunchCallBack();

    }

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

// CCalenCmdLineLauncher::CalendarLaunchCallBack

// Called by StaticCalendarLaunchCallBack, traps leaving version

// of function and handles any errors.

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

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

//

TInt CCalenCmdLineLauncher::CalendarLaunchCallBack()

    {

    TRACE_ENTRY_POINT;

    TInt returnValue = 0;

    TRAPD( error, returnValue = CalendarLaunchCallBackL() );

    if ( error != KErrNone )

        {

        if ( iIsExitOnDlgClose )

           {

           // If there has been an error, gracefully exit.

           TRAPD(error,AppUi().ProcessCommandL( EAknSoftkeyExit ));

           if(error!=KErrNone)

           		{

        		// do avoid warning

        		}

           }

        }

    TRACE_EXIT_POINT;    

    return returnValue;

    }

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

// CCalenCmdLineLauncher::CalendarLaunchCallBack

// Called from processcommand parameters using CAsyncCallBack

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

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

//

TInt CCalenCmdLineLauncher::CalendarLaunchCallBackL()

    {

    TRACE_ENTRY_POINT;

    // When entering this function, the Calendar window group

    // should be at ordinal -1.  

    // When opening to a new entry editor, we should restore the

    // window group to ordinal 0 before calling EditNewEntryL

    if( iCmdParameters.iFlag )

        {

        iIsExitOnDlgClose = EFalse;

        }

    else

        {

        iIsExitOnDlgClose = ETrue;

        }

    RWindowGroup& windowGroup = CCoeEnv::Static()->RootWin(); 

    switch( iCmdParameters.iCommandType )

        {       

        case CCalenCmdLineParser::EStartTypeNewMeeting:

            // Launch a new entry editor

            windowGroup.SetOrdinalPosition( 0, 0 );

            iController.IssueCommandL( ECalenNewMeeting );

            break;

        case CCalenCmdLineParser::EStartTypeNewMeetingRequest:

            windowGroup.SetOrdinalPosition( 0, 0 );

            // Launch a new meeting request editor

            iController.IssueCommandL( ECalenNewMeetingRequest );

            break;

        case CCalenCmdLineParser::EStartTypeNewAnniv:

            windowGroup.SetOrdinalPosition( 0, 0 );

            // Launch a new anniversary editor

            iController.IssueCommandL( ECalenNewAnniv );

            break;

        case CCalenCmdLineParser::EStartTypeNewTodo:

            windowGroup.SetOrdinalPosition( 0, 0 );

            // Launch a new Todo editor

            iController.IssueCommandL( ECalenNewTodo );

            break;

        default:

            iIsExitOnDlgClose = EFalse;

            break;

        }

    TRACE_EXIT_POINT;

    return KLeaveExit;

    }

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

// CCalenCmdLineLauncher::HandleNotification

// Handles notifications

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

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

//

 void CCalenCmdLineLauncher::HandleNotification(const TCalenNotification aNotification )

    {

    TRACE_ENTRY_POINT;

	if( aNotification == ECalenNotifyInstanceDeleted || aNotification == ECalenNotifyEntryDeleted )

		{

		// Exit when event is deleted from EventView

		if( iCmdParameters.iCommandType == CCalenCmdLineParser::EStartTypeUid 

			|| iCmdParameters.iCommandType == CCalenCmdLineParser::EStartTypeUidViewer

			|| iCmdParameters.iCommandType == CCalenCmdLineParser::EStartTypeUidAlarmViewer

			|| iCmdParameters.iCommandType == CCalenCmdLineParser::EStartTypeUidAlarmViewerNoSnooze)

			{ 

			if(iIsExitOnDlgClose)

			    {

			    PIM_TRAPD_HANDLE( AppUi().ProcessCommandL(EAknSoftkeyExit) );	

			    iIsExitOnDlgClose = EFalse;

			    }

			}

		}

    else if(aNotification == ECalenNotifyEntryClosed)

    	{

        // Exit when Escape pressed in Eventview

    	if(iIsExitOnDlgClose)

            {

            PIM_TRAPD_HANDLE( AppUi().ProcessCommandL(EAknSoftkeyExit) );

           // iIsExitOnDlgClose = EFalse;

            }

        }

    else if( iIsExitOnDlgClose )

        {

        PIM_TRAPD_HANDLE( AppUi().ProcessCommandL(EAknSoftkeyExit) );

        }

    else if(aNotification == ECalenNotifySettingsClosed)

        {

        PIM_TRAPD_HANDLE( AppUi().ProcessCommandL(EAknSoftkeyExit) );

        } 

    else

        {

        }

    TRACE_EXIT_POINT;

    }

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

 // CCalenCmdLineLauncher::SetExitOnDialogclose

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

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