diff -r cad71a31b7fc -r e36f3802f733 srsf/vcommandexecutor/src/nssvcapplauncher.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/srsf/vcommandexecutor/src/nssvcapplauncher.cpp Wed Sep 01 12:29:17 2010 +0100 @@ -0,0 +1,1445 @@ +/* +* 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 +#include +#include +#include // TApaTask, TApaTaskList +#include // CApaCommandLine +#include +#include // RFs +#include // BaflUtils +#include +#include +#include + + +#include + +#include // 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( 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 + { + delete oper; + // "Operator information not available" + GetLocalizedStringL( EOperatorNotAvailable, operStatusString ); + CleanupStack::PushL( operStatusString ); + iStatusInfo = operStatusString->Des().Alloc(); + CleanupStack::PopAndDestroy( operStatusString ); + } + PlaybackStatusInfoL(); + } + +// ---------------------------------------------------------------------------- +// CNssVCAppLauncher::StatusBatteryL +// Provides the answer to the voice command "What is the battery strength?" +// ---------------------------------------------------------------------------- +// +void CNssVCAppLauncher::StatusBatteryL() + { + RUBY_DEBUG_BLOCKL( "CNssVCAppLauncher::StatusBatteryL" ); + + TSpokenStatusInfo battStrength; + GetBatteryStrengthL( battStrength ); + + HBufC* battStatusString; + + switch ( battStrength ) + { + case EBatteryFull: + // "The battery is full" + GetLocalizedStringL( EBatteryFull, battStatusString ); + iStatusInfo = battStatusString; + break; + + case EBattetteryAlmostFull: + // "The battery is almost full" + GetLocalizedStringL( EBattetteryAlmostFull, battStatusString ); + iStatusInfo = battStatusString; + break; + + case EBatteryHalfFull: + // "The battery is half full" + GetLocalizedStringL( EBatteryHalfFull, battStatusString ); + iStatusInfo = battStatusString; + break; + + case EBatteryAlmostEmpty: + // "The battery is almost empty" + GetLocalizedStringL( EBatteryAlmostEmpty, battStatusString ); + iStatusInfo = battStatusString; + break; + + case EBatteryLow: + // "The battery is low. Please recharge" + GetLocalizedStringL( EBatteryLow, battStatusString ); + iStatusInfo = battStatusString; + break; + + case EBatteryStrengthNotAvailable: + // "Battery strength information not available" + GetLocalizedStringL( EBatteryStrengthNotAvailable, battStatusString ); + iStatusInfo = battStatusString; + break; + } + + PlaybackStatusInfoL(); + } + +// ---------------------------------------------------------------------------- +// CNssVCAppLauncher::StatusSignalL +// Provides the answer to the voice command "What is the signal strength?" +// ---------------------------------------------------------------------------- +// +void CNssVCAppLauncher::StatusSignalL() + { + RUBY_DEBUG_BLOCKL( "CNssVCAppLauncher::StatusSignalL" ); + + TSpokenStatusInfo signalStrength; + GetSignalStrengthL( signalStrength ); + + HBufC* signalStatusString; + + switch ( signalStrength ) + { + case ESignalStrengthExcellent: + // "The network strength is excellent" + GetLocalizedStringL( ESignalStrengthExcellent, signalStatusString ); + iStatusInfo = signalStatusString; + break; + + case ESignalStrengthGood: + // "The network strength is good" + GetLocalizedStringL( ESignalStrengthGood, signalStatusString ); + iStatusInfo = signalStatusString; + break; + + case ESignalStrengthRatherGood: + // "The network strength is rather good" + GetLocalizedStringL( ESignalStrengthRatherGood, signalStatusString ); + iStatusInfo = signalStatusString; + break; + + case ESignalStrengthLow: + // "The network strength is low" + GetLocalizedStringL( ESignalStrengthLow, signalStatusString ); + iStatusInfo = signalStatusString; + break; + + case ESignalStrengthNoSignal: + // "No network" + GetLocalizedStringL( ESignalStrengthNoSignal, signalStatusString ); + iStatusInfo = signalStatusString; + break; + + case ESignalStrengthNotAvailable: + // "Signal strength information not available" + GetLocalizedStringL( ESignalStrengthNotAvailable, signalStatusString ); + iStatusInfo = signalStatusString; + break; + } + + PlaybackStatusInfoL(); + } + +// ---------------------------------------------------------------------------- +// CNssVCAppLauncher::PlaybackStatusInfoL +// Performs text to speech answer for a status query. +// ---------------------------------------------------------------------------- +// +void CNssVCAppLauncher::PlaybackStatusInfoL() + { + RUBY_DEBUG_BLOCKL( "CNssVCAppLauncher::PlaybackStatusInfoL" ); + + __ASSERT_ALWAYS( iStatusInfo, + User::Panic( KPanicCategory, KErrArgument ) ); + + RUBY_DEBUG1( "TTS text: \"%S\"", iStatusInfo ); + + // TTS utility for playback + iTts = CTtsUtility::NewL( *this ); + + // Create TTS style with language + NLP on + TTtsStyle style; + style.iNlp = ETrue; + style.iLanguage = User::Language(); + + // Add style to TTS + TTtsStyleID styleId = iTts->AddStyleL( style ); + + // Segment + TTtsSegment segment( styleId ); + + // Parsed text + iParsedText = CTtsParsedText::NewL(); + iParsedText->SetTextL( *iStatusInfo ); + segment.SetTextPtr( iParsedText->Text() ); + iParsedText->AddSegmentL( segment ); + + // Run synthesis + iTts->OpenAndPlayParsedTextL( *iParsedText ); + + if ( !iWait.IsStarted() ) + { + iWait.Start(); + } + } + +// ----------------------------------------------------------------------------- +// CNssVCAppLauncher::MapcPlayComplete +// Callback, playback has been initialized. +// ----------------------------------------------------------------------------- +// +void CNssVCAppLauncher::MapcInitComplete( TInt aError, + const TTimeIntervalMicroSeconds& /*aDuration*/ ) + { + RUBY_DEBUG1( "CNssVCAppLauncher::MapcInitComplete [%d]", aError ); + + if ( ( aError != KErrNone ) && ( iWait.IsStarted() ) ) + { + iWait.AsyncStop(); + } + } + +// ----------------------------------------------------------------------------- +// CNssVCAppLauncher::MapcPlayComplete +// Callback, playback has been completed. +// ----------------------------------------------------------------------------- +// +#if defined(_DEBUG) && !defined(__RUBY_DEBUG_DISABLED) +void CNssVCAppLauncher::MapcPlayComplete( TInt aError ) +#else +void CNssVCAppLauncher::MapcPlayComplete( TInt /*aError*/ ) +#endif + { + RUBY_DEBUG1( "NssVCAppLauncher::MapcPlayComplete [%d]", aError ); + + if ( iTts ) + { + iTts->Stop(); + iTts->Close(); + } + if ( iWait.IsStarted() ) + { + iWait.AsyncStop(); + } + } + +// ----------------------------------------------------------------------------- +// CNssVCAppLauncher::GetAmOrPmL +// Tells whether it is am or pm. +// ----------------------------------------------------------------------------- +void CNssVCAppLauncher::GetAmOrPmL( const TTime& aTime, TAmPm& aTod ) + { + RUBY_DEBUG_BLOCKL( "CNssVCAppLauncher::GetAmOrPmL" ); + + TTime time = aTime; + // Add one day + time += TTimeIntervalDays( 1 ); + // Copy to TDateTime object + TDateTime dateTime = time.DateTime(); + // Set to midnight + dateTime.SetHour( 0 ); + dateTime.SetMinute( 0 ); + dateTime.SetMicroSecond( 0 ); + // Copy to TTime object + time = dateTime; + + TTimeIntervalHours hours; + aTime.HoursFrom( time, hours ); + // Hours from midnight + TInt hoursInt = hours.Int(); + if ( hours.Int() > -12 ) + { + aTod = EPm; + } + else + { + aTod = EAm; + } + } + +// ----------------------------------------------------------------------------- +// CNssVCAppLauncher::GetOperatorL +// Gets network operator's name. +// ----------------------------------------------------------------------------- +void CNssVCAppLauncher::GetOperatorL( TDesC*& aOperator ) + { + RUBY_DEBUG_BLOCKL( "CNssVCAppLauncher::GetOperatorL" ); + + TFileName tsyName; + GetTSYNameL( tsyName ); + RTelServer server; + User::LeaveIfError( server.Connect() ); + server.LoadPhoneModule( tsyName ); + + RMobilePhone::TMobilePhoneNetworkInfoV1 networkInfo; + RMobilePhone::TMobilePhoneNetworkInfoV1Pckg networkInfoPkg( networkInfo ); + RMobilePhone::TMobilePhoneLocationAreaV1 locationInfo; + + TRequestStatus reqStatus = KErrNone; + RMobilePhone phone; + RTelServer::TPhoneInfo info; + User::LeaveIfError( server.GetPhoneInfo( 0, info ) ); + User::LeaveIfError( phone.Open( server, info.iName ) ); + phone.GetCurrentNetwork( reqStatus, networkInfoPkg, locationInfo ); + + User::WaitForRequest( reqStatus ); + if( reqStatus == KErrNone ) + { + TBuf<256> networkName; + networkName.Copy( networkInfo.iLongName ); + HBufC* oper = networkName.AllocL(); + aOperator = oper; + } + + phone.Close(); + server.UnloadPhoneModule( tsyName ); + server.Close(); + } + +// ----------------------------------------------------------------------------- +// CNssVCAppLauncher::GetBatteryStrengthL +// Gets the battery strength. +// ----------------------------------------------------------------------------- +void CNssVCAppLauncher::GetBatteryStrengthL( TSpokenStatusInfo& aBattStrength ) + { + RUBY_DEBUG_BLOCKL( "CNssVCAppLauncher::GetBatteryStrengthL" ); + + aBattStrength = EBatteryStrengthNotAvailable; + + TFileName tsyName; + GetTSYNameL( tsyName ); + RTelServer server; + User::LeaveIfError( server.Connect() ); + server.LoadPhoneModule( tsyName ); + + TRequestStatus reqStatus = KErrNone; + RMobilePhone phone; + RTelServer::TPhoneInfo info; + User::LeaveIfError( server.GetPhoneInfo( 0, info ) ); + User::LeaveIfError( phone.Open( server, info.iName ) ); + + TUint32 batteryCaps; + // Test if battery strength can be obtained + if ( phone.GetBatteryCaps( batteryCaps ) != KErrNone ) + { + return; + } + + TInt charge = -1; + if ( batteryCaps & RMobilePhone::KCapsGetBatteryInfo ) + { + RMobilePhone::TMobilePhoneBatteryInfoV1 mobilePhoneBatteryInfo; + TRequestStatus status; + phone.GetBatteryInfo( status, mobilePhoneBatteryInfo ); + User::WaitForRequest( status ); + User::LeaveIfError( status.Int() ); + if ( mobilePhoneBatteryInfo.iStatus == RMobilePhone::EPoweredByBattery ) + { + // The percentage battery charge level + charge = mobilePhoneBatteryInfo.iChargeLevel; + if ( charge >= KBatteryFull ) + { + aBattStrength = EBatteryFull; + } + else if ( charge >= KBatteryAlmostFull ) + { + aBattStrength = EBattetteryAlmostFull; + } + else if ( charge >= KBatteryHalfFull ) + { + aBattStrength = EBatteryHalfFull; + } + else if ( charge >= KBatteryAlmostEmpty ) + { + aBattStrength = EBatteryAlmostEmpty; + } + else + { + aBattStrength = EBatteryLow; + } + } + } + //else BATTERY INFO NOT AVAILABLE + + phone.Close(); + server.UnloadPhoneModule( tsyName ); + server.Close(); + } + +// ----------------------------------------------------------------------------- +// CNssVCAppLauncher::GetSignalStrengthL +// Gets the signal strength. +// ----------------------------------------------------------------------------- +void CNssVCAppLauncher::GetSignalStrengthL( TSpokenStatusInfo& aSignalStrength ) + { + RUBY_DEBUG_BLOCKL( "CNssVCAppLauncher::GetSignalStrengthL" ); + + aSignalStrength = ESignalStrengthNotAvailable; + + TFileName tsyName; + GetTSYNameL( tsyName ); + RTelServer server; + User::LeaveIfError( server.Connect() ); + server.LoadPhoneModule( tsyName ); + + RMobilePhone phone; + RTelServer::TPhoneInfo info; + User::LeaveIfError( server.GetPhoneInfo( 0, info ) ); + User::LeaveIfError( phone.Open( server, info.iName ) ); + + TUint32 signalCaps; + // Test if signal information can be obtained + User::LeaveIfError( phone.GetSignalCaps( signalCaps ) ); + + TInt32 signalStrength = -1; + TInt8 bars = -1; + if ( signalCaps & RMobilePhone::KCapsGetSignalStrength ) + { + TRequestStatus status = KErrNone; + phone.GetSignalStrength( status, signalStrength, bars ); + User::WaitForRequest( status ); + RUBY_DEBUG1( "Signal strength in dBm: %d", signalStrength ); + RUBY_DEBUG1( "Number of signal bars: %d", bars ); + if ( bars >= KSignalExcellent ) + { + aSignalStrength = ESignalStrengthExcellent; + } + else if ( bars == KSignalGood ) + { + aSignalStrength = ESignalStrengthGood; + } + else if ( bars >= KSignalRatherGood ) + { + aSignalStrength = ESignalStrengthRatherGood; + } + else if ( bars >= KSignalLow ) + { + aSignalStrength = ESignalStrengthLow; + } + else if ( bars == KSignalNone ) + { + aSignalStrength = ESignalStrengthNoSignal; + } + } + + phone.Close(); + server.UnloadPhoneModule( tsyName ); + server.Close(); + } + +// ----------------------------------------------------------------------------- +// CNssVCAppLauncher::CalendarDayViewL +// Activates calendars day view. +// ----------------------------------------------------------------------------- +void CNssVCAppLauncher::CalendarDayViewL( const TInt aDay ) + { + RUBY_DEBUG_BLOCKL( "CNssVCAppLauncher::CalendarDayViewL" ); + + __ASSERT_ALWAYS( aDay >= EMonday && aDay <= ETomorrow, + User::Panic( KPanicCategory, KErrArgument ) ); + + TTime time; + // Current date + time.HomeTime(); + TDateTime dateTime = time.DateTime(); + // TTime::DayNoInMonth()'s first day in month is zero + const TInt KCurrentDayInMonth = time.DayNoInMonth() + 1; + const TInt KCurrentDayInWeek = time.DayNoInWeek(); + const TInt KCurrentMonth = dateTime.Month(); + const TInt KCurrentYear = dateTime.Year(); + // Variables used to form parameters for calendar launching + TInt day = KCurrentDayInMonth; + TInt month = KCurrentMonth; + TInt year = KCurrentYear; + + // Command for weekday + if( aDay >= EMonday && aDay <= ESunday ) + { + if ( KCurrentDayInWeek <= aDay ) + { + // Depend on existing enum values, not good + day += aDay - KCurrentDayInWeek; + } + else if ( KCurrentDayInWeek > aDay ) + { + // Depend on existing enum values, not good + // Go to monday of next week and add whatever is necessery + day += KDaysInAWeek - KCurrentDayInWeek + aDay; + } + + // Month changes + if ( day > time.DaysInMonth() ) + { + day -= time.DaysInMonth(); + // Year changes + if ( month == EDecember ) + { + month = EJanuary; + year++; + } + else + { + month++; + } + } + } + // Command for tomorrow + else if ( aDay == ETomorrow ) + { + day++; + // Month changes + if ( day > time.DaysInMonth() ) + { + // First day + day = 1; + month++; + + // Year changes + if ( KCurrentMonth == EDecember ) + { + month = EJanuary; + year++; + } + } + } + + // Offset for TMonth is zero, so we add one + month++; + + HBufC16* cmdLine = HBufC16::NewLC( KCalendarDayCmdLine().Length() * 2 ); // Just to be on the safe side + cmdLine->Des().Format( KCalendarDayCmdLine, year, month, day ); + + // Launch calendar + ActivateAppL( KUidAppCalendar, cmdLine ); + + CleanupStack::PopAndDestroy( cmdLine ); + } + +// ----------------------------------------------------------------------------- +// CNssVCAppLauncher::CalendarWeekViewL +// Launches calendars week view to a selected week. +// ----------------------------------------------------------------------------- +void CNssVCAppLauncher::CalendarWeekViewL( const TInt aWeek ) + { + RUBY_DEBUG_BLOCKL( "CNssVCAppLauncher::CalendarWeekViewL" ); + + __ASSERT_ALWAYS( aWeek == EThisWeek || aWeek == ENextWeek, + User::Panic( KPanicCategory, KErrArgument ) ); + + TLocale locale; + TTime time; + // Current date + time.HomeTime(); + TDateTime dateTime = time.DateTime(); + // TTime::DayNoInMonth()'s first day in month is zero + const TInt KCurrentDayInMonth = time.DayNoInMonth() + 1; + // According to documentation, TTime::DayNoInWeek() should honour the + // setting specified in TLocale::SetStartOfWeek(). It doesn't though. + TInt currentDayInWeek; + if( time.DayNoInWeek() >= locale.StartOfWeek() ) + { + currentDayInWeek = time.DayNoInWeek() - locale.StartOfWeek() ; + } + else + { + currentDayInWeek = KDaysInAWeek - locale.StartOfWeek() + time.DayNoInWeek(); + } + const TInt KCurrentDayInWeek = currentDayInWeek; + const TInt KCurrentMonth = dateTime.Month(); + const TInt KCurrentYear = dateTime.Year(); + // Variables used to form parameters for calendar launching + TInt year = KCurrentYear; + TInt month = KCurrentMonth; + TInt day = KCurrentDayInMonth; + TInt hour = dateTime.Hour(); + + if ( aWeek == ENextWeek ) + { + // 8 am + hour = 8; + // Go to the first day of next week + day += KDaysInAWeek - KCurrentDayInWeek; + + // Month changes + if( day > time.DaysInMonth() ) + { + day -= time.DaysInMonth(); + month++; + + // Year changes + if ( KCurrentMonth == EDecember ) + { + year++; + month = EJanuary; + } + } + } + + // Offset for TMonth is zero, so we add one + month++; + + HBufC16* cmdLine = HBufC16::NewLC( KCalendarWeekCmdLine().Length() * 2 ); // Just to be on the safe side + cmdLine->Des().Format( KCalendarWeekCmdLine, year, month, day, hour ); + + // Launch calendar + ActivateAppL( KUidAppCalendar, cmdLine ); + + CleanupStack::PopAndDestroy( cmdLine ); + } + +// ----------------------------------------------------------------------------- +// CNssVCAppLauncher::CalendarMonthViewL +// Launches calendars month view to a selected month. +// ----------------------------------------------------------------------------- +void CNssVCAppLauncher::CalendarMonthViewL( const TInt aMonth ) + { + RUBY_DEBUG_BLOCKL( "CNssVCAppLauncher::CalendarMonthViewL" ); + + __ASSERT_ALWAYS( aMonth >= EMonday && aMonth <= ENextMonth, + User::Panic( KPanicCategory, KErrArgument ) ); + + TTime time; + // Current date + time.HomeTime(); + TDateTime dateTime = time.DateTime(); + const TInt KCurrentMonth = dateTime.Month(); + // Variables used to form parameters for calendar launching + TInt year = dateTime.Year(); + TInt month = KCurrentMonth; + // TDateTime::Day() offset is zero + TInt day = dateTime.Day() + 1; + + if ( aMonth >= EJanuary && aMonth <= EDecember ) + { + if( aMonth != KCurrentMonth ) + { + day = 1; + } + month = aMonth; + // If the requested month is already past for this year + // month view is openend for next year. + if ( aMonth < KCurrentMonth ) + { + year++; + } + } + else if ( aMonth == ENextMonth ) + { + day = 1; + if ( KCurrentMonth == EDecember ) + { + year++; + month = EJanuary; + } + else + { + month++; + } + } + + // Offset for TMonth is zero, so we add one + month++; + + HBufC16* cmdLine = HBufC16::NewLC( KCalendarMonthCmdLine().Length() * 2 ); // Just to be on the safe side + cmdLine->Des().Format( KCalendarMonthCmdLine, year, month, day ); + + // Launch calendar + ActivateAppL( KUidAppCalendar, cmdLine ); + + CleanupStack::PopAndDestroy( cmdLine ); + } + +// ----------------------------------------------------------------------------- +// CNssVCAppLauncher::GetOpenHomepageL +// Opens browser with the user defined homepage. +// ----------------------------------------------------------------------------- +void CNssVCAppLauncher::OpenHomepageL() + { + RUBY_DEBUG_BLOCKL( "CNssVCAppLauncher::OpenHomepageL" ); + + // Command line parameter for starting the browser with start page + HBufC16* cmdLine = KBrowserArgStartPage().AllocLC(); + + // Launch browser + ActivateAppL( KUidAppBrowser, cmdLine ); + + CleanupStack::PopAndDestroy( cmdLine ); + } + +// ----------------------------------------------------------------------------- +// CNssVCAppLauncher::GetTSYNameL +// Gets the name of the currently selected TSY. +// ----------------------------------------------------------------------------- +void CNssVCAppLauncher::GetTSYNameL( TDes& aTSYName ) + { + RUBY_DEBUG_BLOCKL( "CNssVCAppLauncher::GetTSYNameL" ); + + CCommsDatabase* const db = CCommsDatabase::NewL( EDatabaseTypeUnspecified ); + CleanupStack::PushL( db ); + TUint32 modemId = 0; + db->GetGlobalSettingL( TPtrC( MODEM_PHONE_SERVICES_SMS ), modemId ); + CCommsDbTableView* const view + = db->OpenViewMatchingUintLC( TPtrC( MODEM ), TPtrC( COMMDB_ID ), + modemId ); + TInt err = view->GotoFirstRecord(); + User::LeaveIfError( err ); + view->ReadTextL( TPtrC( MODEM_TSY_NAME ), aTSYName ); + CleanupStack::PopAndDestroy( view ); + CleanupStack::PopAndDestroy( db ); + } + +// ----------------------------------------------------------------------------- +// CNssVCAppLauncher::ExecuteMediaCommandL +// Executes a media command using Symbian Remote Control FW. +// ----------------------------------------------------------------------------- +void CNssVCAppLauncher::ExecuteMediaCommandL( TUint aMediaCommandId ) + { + RUBY_DEBUG_BLOCKL( "CNssVCAppLauncher::ExecuteMediaCommandL" ); + + __ASSERT_ALWAYS( aMediaCommandId >= EMediaPlay && + aMediaCommandId <= EMediaVolumeDown, + User::Panic( KPanicCategory, KErrArgument ) ); + + CRemConInterfaceSelector* interfaceSelector + = CRemConInterfaceSelector::NewL(); + + // Owned by interfaceSelector + CRemConCoreApiController* coreIf + = CRemConCoreApiController::NewL( *interfaceSelector, *this ); + + interfaceSelector->OpenControllerL(); + + TRemConAddress addr; + addr.BearerUid() = KUidVCExecutorBearer; + // No bearer-specific connection data + interfaceSelector->GoConnectionOrientedL( addr ); + + TRequestStatus status; + + interfaceSelector->ConnectBearer( status ); + User::WaitForRequest( status ); + + TUint numRemotes; + + switch ( aMediaCommandId ) + { + // TODO: remove User::After calls. They are for testing purposes only. + case EMediaPlay: + coreIf->PausePlayFunction( status, numRemotes, + ERemConCoreApiButtonPress ); + User::WaitForRequest( status ); + break; + + case EMediaPause: + coreIf->Pause( status, numRemotes, ERemConCoreApiButtonClick ); + User::WaitForRequest( status ); + break; + + case EMediaStop: + coreIf->Stop( status, numRemotes, ERemConCoreApiButtonClick ); + User::WaitForRequest( status ); + break; + + case EMediaNextSong: + coreIf->Forward( status, numRemotes, ERemConCoreApiButtonClick ); + User::WaitForRequest( status ); + break; + + case EMediaNextChannel: + coreIf->Forward( status, numRemotes, ERemConCoreApiButtonClick ); + User::WaitForRequest( status ); + break; + + case EMediaPreviousSong: + coreIf->Backward( status, numRemotes, ERemConCoreApiButtonClick ); + User::WaitForRequest( status ); + break; + + case EMediaPreviousChannel: + coreIf->Backward( status, numRemotes, ERemConCoreApiButtonClick ); + User::WaitForRequest( status ); + break; + + case EMediaChannelUp: + coreIf->ChannelUp( status, numRemotes, ERemConCoreApiButtonClick ); + User::WaitForRequest( status ); + break; + + case EMediaChannelDown: + coreIf->ChannelDown( status, numRemotes, + ERemConCoreApiButtonClick ); + User::WaitForRequest( status ); + break; + + case EMediaVolumeUp: + coreIf->VolumeUp( status, numRemotes, ERemConCoreApiButtonClick ); + User::WaitForRequest( status ); + break; + + case EMediaVolumeDown: + coreIf->VolumeDown( status, numRemotes, ERemConCoreApiButtonClick ); + User::WaitForRequest( status ); + break; + } + + delete interfaceSelector; + interfaceSelector = NULL; + } + +// ----------------------------------------------------------------------------- +// CNssVCAppLauncher::MrccacoResponse +// Called by RemCon as a response for a remote control command sent by this +// RemCon controller client +// ----------------------------------------------------------------------------- +void CNssVCAppLauncher::MrccacoResponse( TRemConCoreApiOperationId /*aOperationId*/, + TInt /*aError*/ ) + { + // Nothing + } + +// ----------------------------------------------------------------------------- +// CNssVCAppLauncher::GetLocalizedStringL +// Gets localized string from the resource file for text-to-speech status info. +// ----------------------------------------------------------------------------- + +void CNssVCAppLauncher::GetLocalizedStringL( TSpokenStatusInfo aStringId, + HBufC*& aString ) + { + RUBY_DEBUG_BLOCKL( "CNssVCAppLauncher::GetLocalizedStringL" ); + + __ASSERT_ALWAYS( aStringId >= ETime24Format && + aStringId <= ESignalStrengthNotAvailable, + User::Panic( KPanicCategory, KErrArgument ) ); + + // load resources + RResourceFile resourceFile; + RFs fileServer; + TBool found( EFalse ); + User::LeaveIfError( fileServer.Connect() ); + CleanupClosePushL( fileServer ); + + // try finding a localized or default resource file browsing through the drivers + TFileName name; + TInt i( 0 ); + // use the first drive + name.Append( KResourceDrivers[i] ); + name.Append( ':' ); + name.Append( KResourceDir ); + name.Append( KResourceFileName ); + + while ( !found && i < KResourceDrivers.Length() ) + { + name[0] = KResourceDrivers[i++]; + + BaflUtils::NearestLanguageFile( fileServer, name ); + + if ( BaflUtils::FileExists(fileServer, name) ) + { + // open resource + resourceFile.OpenL( fileServer, name ); + CleanupClosePushL( resourceFile ); + resourceFile.ConfirmSignatureL(); + found = ETrue; + } + } + + if ( !found ) + { + User::Leave( KErrNotFound ); + } + + TResourceReader reader; + + // Get correct localized string + switch ( aStringId ) + { + case ETime24Format: + reader.SetBuffer( resourceFile.AllocReadLC( PROMPT_TIME24 ) ); + break; + + case ETimeAm: + reader.SetBuffer( resourceFile.AllocReadLC( PROMPT_TIME12AM ) ); + break; + + case ETimePm: + reader.SetBuffer( resourceFile.AllocReadLC( PROMPT_TIME12PM ) ); + break; + + case EOperator: + reader.SetBuffer( resourceFile.AllocReadLC( PROMPT_OPERATOR ) ); + break; + + case EOperatorNotAvailable: + reader.SetBuffer( resourceFile.AllocReadLC( PROMPT_NOOPERATOR ) ); + break; + + case EBatteryFull: + reader.SetBuffer( resourceFile.AllocReadLC( PROMPT_BATTERYFULL ) ); + break; + + case EBattetteryAlmostFull: + reader.SetBuffer( resourceFile.AllocReadLC( PROMPT_BATTERYALMOSTFULL ) ); + break; + + case EBatteryHalfFull: + reader.SetBuffer( resourceFile.AllocReadLC( PROMPT_BATTERYHALF ) ); + break; + + case EBatteryAlmostEmpty: + reader.SetBuffer( resourceFile.AllocReadLC( PROMPT_BATTERYALMOSTEMPTY ) ); + break; + + case EBatteryLow: + reader.SetBuffer( resourceFile.AllocReadLC( PROMPT_BATTERYLOW ) ); + break; + + case EBatteryStrengthNotAvailable: + reader.SetBuffer( resourceFile.AllocReadLC( PROMPT_NOBATTERY ) ); + break; + + case ESignalStrengthExcellent: + reader.SetBuffer( resourceFile.AllocReadLC( PROMPT_NETWORKEXCELLENT ) ); + break; + + case ESignalStrengthGood: + reader.SetBuffer( resourceFile.AllocReadLC( PROMPT_NETWORKGOOD ) ); + break; + + case ESignalStrengthRatherGood: + reader.SetBuffer( resourceFile.AllocReadLC( PROMPT_NETWORKRATHERGOOD ) ); + break; + + case ESignalStrengthLow: + reader.SetBuffer( resourceFile.AllocReadLC( PROMPT_NETWORKLOW ) ); + break; + + case ESignalStrengthNoSignal: + reader.SetBuffer( resourceFile.AllocReadLC( PROMPT_NETWORKNONE ) ); + break; + + case ESignalStrengthNotAvailable: + reader.SetBuffer( resourceFile.AllocReadLC( PROMPT_NONETWORK ) ); + break; + + default: + break; + + } + + aString = reader.ReadHBufCL(); + + CleanupStack::PopAndDestroy(); // AllocReadLC + + CleanupStack::PopAndDestroy( &resourceFile ); + CleanupStack::PopAndDestroy( &fileServer ); + } + +// End of File