/*

* Copyright (c) 2005-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:  This is an implementation class for checking which 

*               application or profile needs to be activated and then

*               Starts it.

*

*/

// INCLUDE FILES

#include "rubydebug.h"

#include "nssvcapplauncher.h"

#include "nssvcapplauncher.hrh"

#include "nssvcapplauncherconstants.h"

#include <etel.h>

#include <etelmm.h>

#include <commdb.h>

#include <apgtask.h>     // TApaTask, TApaTaskList

#include <apacmdln.h>    // CApaCommandLine

#include <e32def.h>

#include <f32file.h>     // RFs

#include <bautils.h>     // BaflUtils

#include <RemConExtensionApi.h>

#include <remconinterfaceselector.h>

#include <remconcoreapicontroller.h>

#include <vcommandexecutor.rsg>

#include <AknGlobalConfirmationQuery.h> // Confirmation query.

// CONSTANTS

_LIT( KPanicCategory, "VCommandExecutor" );

//Command line parameter for launching calendar to day view

_LIT16( KCalendarDayCmdLine, "DATE %d %d %d 08 00 00 000000" );

//Command line parameter for launching calendar to week view

_LIT16( KCalendarWeekCmdLine, "WEEK %d %d %d %d 00 00 000000" );

//Command line parameter for launching calendar to month view

_LIT16( KCalendarMonthCmdLine, "MONTH %d %d %d 08 00 00 000000" );

// Command line parameter for Browser application for opening the browser

// to start page

_LIT16( KBrowserArgStartPage, "5" );

// Battery charge level in percentage scaled to five values

const TInt KBatteryFull = 85; // full >= 85

const TInt KBatteryAlmostFull = 65; // 65 <= almost full < 85 

const TInt KBatteryHalfFull = 35; // 35 <= half full < 65

const TInt KBatteryAlmostEmpty = 15; // 15 <= almost empty < 35

// low < 15

// Signal strength level in seven bars scaled to five values

const TInt KSignalExcellent = 6; // excellent >= 6

const TInt KSignalGood = 5; // good == 5 

const TInt KSignalRatherGood = 3; // 3 <= rather good < 5

const TInt KSignalLow = 1; // 1 <= low < 3

const TInt KSignalNone = 0;

// low < 15

// letters for drives in search order

const TBuf<1> KResourceDrivers = _L("z"); 

_LIT( KResourceDir, "\\resource\\" );

_LIT( KResourceFileName, "VCommandExecutor.rsc" );

// String from loc-file must be modified for TTime::FormatL function

_LIT( KLocFileHourString, "%0N" );

_LIT( KLocFileMinuteString, "%1N" );

_LIT( KTTimeHourString, "%J");

_LIT( KTTimeHourStringWithZero, "0%J");

_LIT( KTTimeMinuteString, "%T");

const TInt KDaysInAWeek = 7;

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

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

// might leave.

//

CNssVCAppLauncher::CNssVCAppLauncher()

    {

    }

// Destructor

CNssVCAppLauncher::~CNssVCAppLauncher()

    {

    if ( iApaLsSession )

        {

        iApaLsSession->Close();

        delete iApaLsSession;

        iApaLsSession = NULL;

        }

    if ( iTts )

        {

        delete iTts;

        iTts = NULL;

        }

    if ( iParsedText )

        {

        delete iParsedText;

        iParsedText = NULL;

        }

    if ( iStatusInfo )

        {

        delete iStatusInfo;

        iStatusInfo = NULL;

        }

    }

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

// CNssVCAppLauncher::ConstructL

// Symbian 2nd phase constructor

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

//

void CNssVCAppLauncher::ConstructL()

    {

    RUBY_DEBUG_BLOCKL( "CNssVCAppLauncher::ConstructL" );

    }

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

// CNssVCAppLauncher* CNssVCAppLauncher::NewL

// Two-phased constructor.

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

//

CNssVCAppLauncher* CNssVCAppLauncher::NewL()                                                           

    {

    RUBY_DEBUG_BLOCKL( "CNssVCAppLauncher::NewL" );

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CNssVCAppLauncher::ExecuteCommandL

// Checks the id and calls the appropriate function.

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

//

TInt CNssVCAppLauncher::ExecuteCommandL( TUint aCommandId )

    {

    RUBY_DEBUG_BLOCKL( "CNssVCAppLauncher::ExecuteCommandL" );

    TInt err = KErrNone;

	switch( aCommandId )

		{

		case ECalendar:

			ActivateAppL( KUidAppCalendar );

			break;

        case ECalendarToday:

			CalendarDayViewL( EToday );

			break;

        case ECalendarTomorrow:

			CalendarDayViewL( ETomorrow );

			break;

        case ECalendarMonday:

			CalendarDayViewL( EMonday );

			break;

        case ECalendarTuesday:

			CalendarDayViewL( ETuesday );

			break;

        case ECalendarWednesday:

			CalendarDayViewL( EWednesday );

			break;

        case ECalendarThursday:

			CalendarDayViewL( EThursday );

			break;

        case ECalendarFriday:

			CalendarDayViewL( EFriday );

			break;

        case ECalendarSaturday:

			CalendarDayViewL( ESaturday );

			break;

        case ECalendarSunday:

			CalendarDayViewL( ESunday );

			break;

        case ECalendarThisWeek:

			CalendarWeekViewL( EThisWeek );

			break;

        case ECalendarNextWeek:

			CalendarWeekViewL( ENextWeek );

			break;

        case ECalendarThisMonth:

			CalendarMonthViewL( EThisMonth );

			break;

        case ECalendarNextMonth:

			CalendarMonthViewL( ENextMonth );

			break;

        case ECalendarJanuary:

			CalendarMonthViewL( EJanuary );

			break;

        case ECalendarFebruary:

			CalendarMonthViewL( EFebruary );

			break;

        case ECalendarMarch:

			CalendarMonthViewL( EMarch );

			break;

        case ECalendarApril:

			CalendarMonthViewL( EApril );

			break;

        case ECalendarMay:

			CalendarMonthViewL( EMay );

			break;

        case ECalendarJune:

			CalendarMonthViewL( EJune );

			break;

        case ECalendarJuly:

			CalendarMonthViewL( EJuly );

			break;

        case ECalendarAugust:

			CalendarMonthViewL( EAugust );

			break;

        case ECalendarSeptember:

			CalendarMonthViewL( ESeptember );

			break;

        case ECalendarOctober:

			CalendarMonthViewL( EOctober );

			break;

        case ECalendarNovember:

			CalendarMonthViewL( ENovember );

			break;

        case ECalendarDecember:

			CalendarMonthViewL( EDecember );

			break;

        case EStatusTime:

		    StatusTimeL();

		    break;

        case EStatusOperator:

		    StatusOperatorL();

		    break;

        case EStatusBatteryStrength:

		    StatusBatteryL();

		    break;

        case EStatusSignalStrength:

		    StatusSignalL();

		    break;

        case EBrowser:

		    ActivateAppL( KUidAppBrowser );

		    break;

        /*case ESMSReader:

            ActivateAppL( KUidAppSMSReader );

            break;*/

        case EMediaPlay:

            ExecuteMediaCommandL( EMediaPlay );

            break;

        case EMediaStop:

            ExecuteMediaCommandL( EMediaStop );

            break;

        case EMediaPause:

            ExecuteMediaCommandL( EMediaPause );

            break;

        case EMediaNextSong:

            ExecuteMediaCommandL( EMediaNextSong );

            break;

        case EMediaNextChannel:

            ExecuteMediaCommandL( EMediaNextChannel );

            break;

        case EMediaPreviousSong:

            ExecuteMediaCommandL( EMediaPreviousSong );

            break;

        case EMediaPreviousChannel:

            ExecuteMediaCommandL( EMediaPreviousChannel );

            break;

        case EMediaVolumeUp:

            ExecuteMediaCommandL( EMediaVolumeUp );

            break;

       case EMediaVolumeDown:

            ExecuteMediaCommandL( EMediaVolumeDown );

            break;

		default:

			err = KErrNotSupported;

			break;

		}

    return err;

    }

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

// CNssVCAppLauncher::CreateConnectionL

// Connects to RApaLsSession.

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

//

void CNssVCAppLauncher::CreateApaConnectionL()

    {

    RUBY_DEBUG_BLOCKL( "CNssVCAppLauncher::CreateApaConnectionL" );

    iApaLsSession = new RApaLsSession();

    if ( !iApaLsSession->Handle() )

        {

        User::LeaveIfError( iApaLsSession->Connect() );

        }

    }

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

// CNssVCAppLauncher::ActivateAppL

// Used to launch applications. Checks whether an instance of the launched

// application is already running.

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

//

void CNssVCAppLauncher::ActivateAppL( const TUid aUid,

                                      const TDesC16* aCmdLine,

                                      TBool aMultipleInstances )

    {

    RUBY_DEBUG_BLOCKL( "CNssVCAppLauncher::ActivateAppL" );

    CreateApaConnectionL();

    if ( aMultipleInstances )

        {

        ActivateAppInstanceL( aUid );

        }

    else

        {

        // Session to window server

        RWsSession wsSession;

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

        TApaTaskList apaTaskList( wsSession );

        TApaTask apaTask = apaTaskList.FindApp( aUid );

        if ( apaTask.Exists() )

            {

            // Already running, close application

            apaTask.EndTask();

            }

        ActivateAppInstanceL( aUid, aCmdLine );

        wsSession.Close();

        }

    }

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

// CNssVCAppLauncher::ActivateAppInstanceL

// Activates an instance of an application.

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

//

void CNssVCAppLauncher::ActivateAppInstanceL( const TUid aUid, const TDesC16* aCmdLine )

    {

    RUBY_DEBUG_BLOCKL( "CNssVCAppLauncher::ActivateAppInstanceL" );

	TApaAppInfo appInfo;

    User::LeaveIfError( iApaLsSession->GetAppInfo( appInfo, aUid ) );

	TFileName appName = appInfo.iFullName;

	CApaCommandLine* apaCommandLine = CApaCommandLine::NewLC();

	apaCommandLine->SetExecutableNameL( appName );

	apaCommandLine->SetCommandL( EApaCommandRun );

	if ( aCmdLine )

	    {

	    // copy the 16-bit data into 8-bit buffer

        HBufC8* paramBuf = HBufC8::NewLC( aCmdLine->Length() *2 );

        TPtr8 tailBuf = paramBuf->Des();

        tailBuf.Copy( reinterpret_cast<const TUint8*>( aCmdLine->Ptr() ), aCmdLine->Length() *2 );

	    // Command line parameters

	    apaCommandLine->SetTailEndL( tailBuf );

	    CleanupStack::PopAndDestroy( paramBuf );

	    }

	User::LeaveIfError ( iApaLsSession->StartApp( *apaCommandLine ) );

	CleanupStack::PopAndDestroy( apaCommandLine );

	}

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

// CNssVCAppLauncher::StatusTimeL

// Provides the answer to the voice command "What time is it?"

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

//

void CNssVCAppLauncher::StatusTimeL()

    {

    RUBY_DEBUG_BLOCKL( "CNssVCAppLauncher::StatusTimeL" );

    TTime time;

    time.HomeTime();

    HBufC* timeStatusString = NULL;

    TLocale locale;

    if ( locale.TimeFormat() == ETime24 )

        {

        // "It is %N0:%N1"

        GetLocalizedStringL( ETime24Format, timeStatusString );

        }

    else // 12-hour format

        {

        TAmPm timeOfDay;

        GetAmOrPmL( time, timeOfDay );

        if ( timeOfDay == EAm )

            {

            // "It is %0N:%1N AM"

            GetLocalizedStringL( ETimeAm, timeStatusString );

            }

        else

            {

            // "It is %0N:%1N PM"

            GetLocalizedStringL( ETimePm, timeStatusString );

            }

        }

    CleanupStack::PushL( timeStatusString );

    // Modify timeStatusString for TTime:FormatL

    TInt index( KErrNotFound );

    index = timeStatusString->Find( KLocFileHourString );

    if( index != KErrNotFound )

        {

        // Hour

    	if ( locale.TimeFormat() == ETime12 && 

                 ( ( time.DateTime().Hour() > 0 && time.DateTime().Hour() < 10 ) || 

                 ( time.DateTime().Hour() > 12 && time.DateTime().Hour() < 22 ) ) )

    	    {

    	    timeStatusString->Des().Replace( index, KLocFileHourString.iTypeLength,

                                             KTTimeHourStringWithZero );

        	}

        else

        	{

        	timeStatusString->Des().Replace( index, KLocFileHourString.iTypeLength,

                                                 KTTimeHourString );

        	}

        }

    index = timeStatusString->Find( KLocFileMinuteString );

    if( index != KErrNotFound )

        {

        // Minute

        timeStatusString->Des().Replace( index, KLocFileMinuteString.iTypeLength,

                                         KTTimeMinuteString );

        }

    iStatusInfo = HBufC::NewL( timeStatusString->Length() );

    TBuf<256> string;

    time.FormatL( string, *timeStatusString );

    iStatusInfo->Des().Append( string );

    CleanupStack::PopAndDestroy( timeStatusString );

    PlaybackStatusInfoL();

    }

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

// CNssVCAppLauncher::StatusOperatorL

// Provides the answer to the voice command "Who is my operator?"

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

//

void CNssVCAppLauncher::StatusOperatorL()

    {

    RUBY_DEBUG_BLOCKL( "CNssVCAppLauncher::StatusOperatorL" );

    // The operator

    TDesC* oper = NULL;

    HBufC* operStatusString = NULL;

    GetOperatorL( oper );

    if ( oper && oper->Length() > 0 )

        {

        CleanupStack::PushL( oper );

        // "Your operator is %U"

        GetLocalizedStringL( EOperator, operStatusString );

        CleanupStack::PushL( operStatusString );

        TInt index( -1 );

        index = operStatusString->Find( _L( "%U" ) );

        if( index > -1 )

           {

           operStatusString->Des().Replace( index, 2, _L( "%S" ) );

           }    

        iStatusInfo = HBufC::NewL( operStatusString->Length() * 2 ); // Just to be on the safe side

        iStatusInfo->Des().Format( operStatusString->Des(), oper );

        CleanupStack::PopAndDestroy( operStatusString );

        CleanupStack::PopAndDestroy( oper );

        }

    else

        {