/*
* Copyright (c) 2006 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 "appcontroller.h"
#include <vcexecutorapp.rsg>
#include "appcontroller.hrh"
#include "appcontrollerconstants.h"
#include <aknlists.h>
#include <aknPopup.h>
#include <apgtask.h> //TApaTask, TApaTaskList
#include <apacmdln.h> //CApaCommandLine
#include <w32std.h> // RWsSession
#include <e32svr.h>
#include <StringLoader.h>
#include <f32file.h>
#include <badesca.h>
#include <bautils.h>
#include <barsc.h>
#include <e32def.h>
#include <PSVariables.h>
#include "appcontrollerpropertyhandler.h"
#include <ctsydomainpskeys.h>
#include <startupdomainpskeys.h>
#include <centralrepository.h>
#include <CoreApplicationUIsSDKCRKeys.h>
#include <aknnotewrappers.h>
#include <featmgr.h>
#include <bldvariant.hrh>
#include <AknQueryDialog.h>
#include <sendui.h> //CreateAndSendMessageL()
#include <TSendingCapabilities.h>
#include <SendUiConsts.h>
#include <MsgArrays.h>
#include <coemain.h>
// Profile Engine API
#include <Profile.hrh>
#include <AknNotifierController.h>
#include <AknGlobalConfirmationQuery.h> // Confirmation query.
#include "appcontrolleractiveobject.h" // CAppControllerActiveObject.
#include <AknGlobalNote.h> // Information note
#include <data_caging_path_literals.hrh> // KDC_RESOURCE_FILES_DIR
#include "rubydebug.h"
#include <aiwdialdata.h>
#include <AiwDialDataTypes.h>
#include <AiwServiceHandler.h>
#include <gslauncher.h>
// Cover UI start
#include "secondarydisplay/appcontrollersecondarydisplayapi.h"
#include "SecondaryDisplay/SecondaryDisplaySysApAPI.h"
// Cover UI end
const TUid KAppManagerUid = { 0x10283321 }; // Control Panel Application Manager UID
const TUid KVoiceCommandUid = { 0x10282C40 }; // Control Panel Voice Command UID
// ================= MEMBER FUNCTIONS =======================
// C++ default constructor can NOT contain any code, that
// might leave.
//
CVCApplicationControllerImpl::CVCApplicationControllerImpl() : iResourceFileOffset( 0 )
{
}
// Destructor
CVCApplicationControllerImpl::~CVCApplicationControllerImpl()
{
if( iApaLsSession )
{
iApaLsSession->Close();
delete iApaLsSession;
}
delete iPropertyHandler;
delete iMsgTypes;
if (iSendUi)
{
delete iSendUi;
}
// Delete active object.
if ( iActiveObject )
{
iActiveObject->Cancel();
delete iActiveObject;
}
if (iProfileEngine)
{
iProfileEngine->Release();
iProfileEngine = NULL;
}
delete iGlobalConfQuery;
delete iQueryDialog;
if ( iCoeEnv && iEikonEnv->EikAppUi() )
{
iEikonEnv->EikAppUi()->RemoveFromStack( this );
}
FeatureManager::UnInitializeLib();
}
// ---------------------------------------------------------
// CVCApplicationControllerImpl::ConstructL
// Symbian 2nd phase constructor
// ---------------------------------------------------------
//
void CVCApplicationControllerImpl::ConstructL()
{
RUBY_DEBUG_BLOCKL( "CVCApplicationControllerImpl::ConstructL" );
// Sets up TLS, must be done before FeatureManager is used.
FeatureManager::InitializeLibL();
iPropertyHandler = CAppControllerPropertyHandler::NewL(
KPSUidCtsyCallInformation, KCTsyCallState, this);
// Create active object to handle note request statuses.
iActiveObject = new (ELeave) CAppControllerActiveObject( *this );
iGlobalConfQuery = CAknGlobalConfirmationQuery::NewL();
}
// ----------------------------------------------------------------
// CVCApplicationControllerImpl* CVCApplicationControllerImpl::NewL
// Two-phased constructor.
// ----------------------------------------------------------------
//
CVCApplicationControllerImpl* CVCApplicationControllerImpl::NewL()
{
CVCApplicationControllerImpl* self= new (ELeave) CVCApplicationControllerImpl();
CleanupStack::PushL(self);
self->ConstructL();
CleanupStack::Pop();
return self;
}
// ---------------------------------------------------------
// CVCApplicationControllerImpl::ExecuteCommandL
// Checks the Id and diverts the application or profile
// to the right launching engine.
// ---------------------------------------------------------
//
TInt CVCApplicationControllerImpl::ExecuteCommandL( TUint aCommandId,
const TDesC& /*aParameters*/ )
{
RUBY_DEBUG_BLOCKL( "CVCApplicationControllerImpl::ExecuteCommandL" );
TInt err = KErrNone;
// The method we're about to launch is an application, recognized by it's first name.
if( aCommandId < KFirstProfileValue )
{
err = DoExecuteCommandL( aCommandId, KNullDesC() );
}
// The method we're about to launch is a profile, recognized by it's first name
else if( ( aCommandId >= KFirstProfileValue) && ( aCommandId < KSecondProfileValue) )
{
aCommandId -= KProfileValue;
ProfileEngL( aCommandId );
}
// The method we're about to launch is a profile, recognized by it's second name
else if ( ( aCommandId >= KSecondProfileValue ) )
{
aCommandId -= KFirstProfileValue;
ProfileEngL( aCommandId );
}
else
{
// Id does not match.
RUBY_DEBUG1( "CVCApplicationControllerImpl::ExecuteCommandL: command id %d not found", aCommandId );
User::Leave( KErrArgument );
}
return err;
}
// ---------------------------------------------------------
// CVCApplicationControllerImpl::DoExecuteCommandL
// Checks the Id and diverts the application or profile
// to the right launching engine.
// ---------------------------------------------------------
//
TInt CVCApplicationControllerImpl::DoExecuteCommandL( TUint aCommandId, const TDesC& /*aParameters*/ )
{
RUBY_DEBUG_BLOCKL( "CVCApplicationControllerImpl::DoExecuteCommandL" );
RUBY_DEBUG1( "CVCApplicationControllerImpl::DoExecuteCommandL. executing command with id %d", aCommandId );
iCallStatus = EFalse;
TInt err = KErrNone;
CGSLauncher* gsLauncher( NULL );
TUid zeroUid = {0};
// Check which app needs to be activated
switch( aCommandId )
{
case EAppVoiceMail:
err = VmbxEngL();
break;
#ifdef __BT
case EAppBluetooth:
err = BTEngL();
break;
#endif
case EAppWriteMessage:
ActivateMessageL( EEditorTypeNewMessage );
break;
case EAppWriteEmail:
ActivateMessageL( EEditorTypeNewEmail );
break;
case EAppWritePostcard:
ActivateMessageL( EEditorTypePostcard );
break;
case EAppApplicationManagerCPView:
gsLauncher = CGSLauncher::NewLC();
gsLauncher->LaunchGSViewL( KAppManagerUid, zeroUid, KNullDesC8 );
CleanupStack::PopAndDestroy( gsLauncher );
break;
case EAppVoiceCommandCPView:
gsLauncher = CGSLauncher::NewLC();
gsLauncher->LaunchGSViewL( KVoiceCommandUid, zeroUid, KNullDesC8 );
CleanupStack::PopAndDestroy( gsLauncher );
break;
default:
err = KErrNotSupported;
break;
}
// Check if it's profile
if ( err == KErrNotSupported && aCommandId >= KProfileIdsStart )
{
ProfileEngL( aCommandId );
}
return err;
}
// ---------------------------------------------------------
// CVCApplicationControllerImpl::ProfileEngL
// Check which profile user wants to activate and do it.
// ---------------------------------------------------------
//
void CVCApplicationControllerImpl::ProfileEngL( TUint aCommandId )
{
RUBY_DEBUG_BLOCKL( "CVCApplicationControllerImpl::ProfileEngL" );
// cut the VAS DB value from aCommandId so we can activate the profile.
iProfileId = 0;
iProfileId = aCommandId -= KProfileValue;
RUBY_DEBUG1( "CVCApplicationControllerImpl::ProfileEngL: Trying to activate profile id: %d", iProfileId );
// Create profile engine
iProfileEngine = CreateProfileEngineL();
// If Off-line profile is supported
if( ( FeatureManager::FeatureSupported( KFeatureIdOfflineMode ) ) &&
// and active profile is Off-line
( iProfileEngine->ActiveProfileId() == EProfileOffLineId ) &&
// and currently focused profile is not Off-line
( iProfileId != EProfileOffLineId ) )
{
// We are changing from Off-line to a normal profile.
// Check if SIM card exists or not
TInt simCStatus( ESimNotPresent );
RProperty simStatus;
User::LeaveIfError(
simStatus.Attach( KPSUidStartup, KPSSimStatus ) );
User::LeaveIfError( simStatus.Get( simCStatus ) );
simStatus.Close();
if( simCStatus == ESimNotPresent )
{
// SIM card does not exist.
// Show an information note and exit from method.
HBufC* infoText = StringLoader::LoadLC( R_TEXT_INSERT_SIM );
CAknInformationNote* note =
new( ELeave ) CAknInformationNote( ETrue );
// Cover UI start
if ( FeatureManager::FeatureSupported( KFeatureIdCoverDisplay ) )
{
// Initializes cover support
note->PublishDialogL( SecondaryDisplay::ECmdShowInsertSimNote,
SecondaryDisplay::KCatSysAp );
}
// Cover UI end
note->ExecuteLD( *infoText );
CleanupStack::PopAndDestroy( infoText );
return;
}
else
{
iState = EQueryDialog;
if ( iCoeEnv && iEikonEnv->EikAppUi() )
{
iEikonEnv->EikAppUi()->AddToStackL( this, ECoeStackPriorityAlert );
}
iQueryDialog = CAknQueryDialog::NewL();
// Cover UI start
if ( FeatureManager::FeatureSupported( KFeatureIdCoverDisplay ) )
{
// Initializes cover support
iQueryDialog->PublishDialogL(
SecondaryDisplay::ECmdShowLeaveOfflineProfileQuery,
SecondaryDisplay::KCatAppController );
}
// Cover UI end
TInt result = iQueryDialog->ExecuteLD( R_LEAVE_OFFLINE_PROFILE_CONFIRMATION_QUERY );
iQueryDialog = NULL;
if ( iCoeEnv && iEikonEnv->EikAppUi() )
{
iEikonEnv->EikAppUi()->RemoveFromStack( this );
}
if ( !result )
{
// SIM card exists.
// User replied that he/she doesn't want to activate RF.
// Exit from method, do not activate the selected profile.
return;
}
}
}
iProfileEngine->SetActiveProfileL( iProfileId );
}
// ---------------------------------------------------------
// CVCApplicationControllerImpl::VmbxEngL()
// Get the Voice mailbox number and make the call.
// ---------------------------------------------------------
//
TInt CVCApplicationControllerImpl::VmbxEngL()
{
RUBY_DEBUG_BLOCK( "CVCApplicationControllerImpl::VmbxEngL" );
iState = EVoiceMail;
TBuf<KVmbxMaxNumberLength> iNumber;
// existing ETel connection should be used in Open() where available
User::LeaveIfError( iVmbx.Open() );
// Get vmbx number, active ALS line used as default
TInt err = iVmbx.GetVmbxNumber( iNumber );
if( err != KErrNone && err != KErrNotFound )
{
User::Leave( err );
}
// If not found, query the user to enter it
if (err == KErrNotFound)
{
RUBY_DEBUG0( "Querying voice mailbox number" );
if ( iVmbx.QueryNumberL(EVmbxNotDefinedQuery, iNumber) )
{
if( iNumber.Length() )
{
RUBY_DEBUG0( "CVCApplicationControllerImpl::VmbxEngL: calling voice mailbox number" );
DialVmbxL( iNumber );
}
else
{
// User entered incorrect number of nothing
// This is handled by the vmbx engine.
}
}
else
{
// User pressed cancel
}
}
// vmbx number was found so just make the call.
else if (!err && iNumber.Length())
{
RUBY_DEBUG0( "CVCApplicationControllerImpl::VmbxEngL: calling voice mailbox number" );
DialVmbxL( iNumber );
}
iVmbx.Close();
return err;
}
// ---------------------------------------------------------
// CVCApplicationControllerImpl::DialVmbxL
// Does the call to voice mailbox number
// ---------------------------------------------------------
//
void CVCApplicationControllerImpl::DialVmbxL( const TDesC& aNumber )
{
CAiwServiceHandler* serviceHandler = CAiwServiceHandler::NewLC();
// Create AIW interest
RCriteriaArray interest;
CleanupClosePushL( interest ); // cleanup stack 2
CAiwCriteriaItem* criteria = CAiwCriteriaItem::NewLC(
KAiwCmdCall, KAiwCmdCall,
_L8( "*" ) ); // cleanup stack 3
TUid base;
base.iUid = KAiwClassBase;
criteria->SetServiceClass( base );
User::LeaveIfError( interest.Append( criteria ) );
// attach to AIW interest
serviceHandler->AttachL( interest );
CAiwDialData* dialData = CAiwDialData::NewLC();
dialData->SetPhoneNumberL( aNumber );
dialData->SetCallType( CAiwDialData::EAIWForcedCS );
CAiwGenericParamList& paramList = serviceHandler->InParamListL();
dialData->FillInParamListL(paramList);
serviceHandler->ExecuteServiceCmdL( KAiwCmdCall,
paramList,
serviceHandler->OutParamListL(),
0,
this );
iWait.Start();
CleanupStack::PopAndDestroy( dialData );
CleanupStack::PopAndDestroy( criteria );
CleanupStack::PopAndDestroy( &interest );
CleanupStack::PopAndDestroy( serviceHandler );
}
// ---------------------------------------------------------
// CVCApplicationControllerImpl::BTEngL()
// Check if BT is on/off and change it.
// ---------------------------------------------------------
//
#ifdef __BT
TInt CVCApplicationControllerImpl::BTEngL()
{
RUBY_DEBUG_BLOCKL( "CVCApplicationControllerImpl::BTEngL" );
TInt err = KErrNone;
TBTPowerStateValue powerState = EBTPowerOff;
CBTEngSettings* mcm = CBTEngSettings::NewLC(NULL); // No callbacks from this environment
// Getter for BT MCM power mode
// returns power mode via powerState reference
err = mcm->GetPowerState( powerState );
if( ( powerState == EBTPowerOff ) && ( !err ) ) // Power is OFF
{
TInt offlineModeOff( 0 ); // possible values are 0 and 1
TInt activationEnabled( 0 ); // possible values are 0 and 1
// Check whether local Bluetooth name is defined
TBuf<KBTMaxNameLength> btName;
mcm->GetLocalName( btName );
if ( btName.Length() <= 0 )
{
// Activate Bluetooth UI
ActivateAppL( KUidAppBtUi );
}
else
{
// Checks whether off-line mode is on and whether Bluetooth can be
// activated in off-line mode
GetOfflineModeFlagsL( offlineModeOff, activationEnabled );
if ( !offlineModeOff )
{
// Choose user interaction
if ( activationEnabled )
{
iState = EQueryDialog;
if ( iCoeEnv && iEikonEnv->EikAppUi() )
{
iEikonEnv->EikAppUi()->AddToStackL( this, ECoeStackPriorityAlert );
}
// Create and show query
//
iQueryDialog = CAknQueryDialog::NewL(CAknQueryDialog::ENoTone);
// Cover UI start
if ( FeatureManager::FeatureSupported( KFeatureIdCoverDisplay ) )
{
// Initializes cover support
iQueryDialog->PublishDialogL(
SecondaryDisplay::ECmdShowOfflineBtActivationQuery,
SecondaryDisplay::KCatAppController );
}
// Cover UI end
TInt result = iQueryDialog->ExecuteLD(R_BT_ACTIVATE_IN_OFFLINE_QUERY);
iQueryDialog = NULL;
if ( iCoeEnv && iEikonEnv->EikAppUi() )
{
iEikonEnv->EikAppUi()->RemoveFromStack( this );
}
if ( result )
{
err = mcm->SetPowerState( EBTPowerOn ); // Set power on
}
}
else
{
HBufC* stringHolder = StringLoader::LoadLC( R_BT_OFFLINE_DISABLED );
CAknInformationNote* note = new (ELeave) CAknInformationNote();
// Cover UI start
if ( FeatureManager::FeatureSupported( KFeatureIdCoverDisplay ) )
{
// Initializes cover support
note->PublishDialogL( SecondaryDisplay::ECmdShowBtDisabledOfflineNote,
SecondaryDisplay::KCatAppController );
}
// Cover UI end
note->ExecuteLD( *stringHolder );
CleanupStack::PopAndDestroy(); //stringHolder
}
}
else
{
// Offline mode is off
//
if ( activationEnabled )
{
err = mcm->SetPowerState( EBTPowerOn ); // Set power on
}
}
}
}
else if(( powerState == EBTPowerOn ) && ( !err )) // Power is ON
{
err = mcm->SetPowerState( EBTPowerOff ); // Set power off
}
CleanupStack::PopAndDestroy( mcm );
if ( err != KErrNone )
{
HBufC* text = StringLoader::LoadLC(R_BT_GENERAL_ERROR);
CAknErrorNote* dlg = new (ELeave) CAknErrorNote(ETrue);
// Cover UI start
if ( FeatureManager::FeatureSupported( KFeatureIdCoverDisplay ) )
{
// Initializes cover support
dlg->PublishDialogL( SecondaryDisplay::ECmdShowBtGeneralErrorNote,
SecondaryDisplay::KCatAppController );
}
// Cover UI end
dlg->ExecuteLD(*text);
CleanupStack::PopAndDestroy(); // text
}
return err;
}
#endif // __BT
// ----------------------------------------------------------
// CVCApplicationControllerImpl::GetOfflineModeFlagsL
// ----------------------------------------------------------
//
void CVCApplicationControllerImpl::GetOfflineModeFlagsL( TInt& aOfflineModeOff,
TInt& aBTActivationEnabled ) const
{
RUBY_DEBUG_BLOCKL( "CVCApplicationControllerImpl::GetOfflineModeFlagsL" );
// Connecting and initialization:
CRepository* repository = CRepository::NewL(KCRUidCoreApplicationUIs);
// Offline mode on?
repository->Get( KCoreAppUIsNetworkConnectionAllowed, aOfflineModeOff );
RUBY_DEBUG1( "CVCApplicationControllerImpl::GetOfflineModeFlagsL: offline status %d", aOfflineModeOff );
// Closing connection:
delete repository;
// BT Activation enabled?
CRepository* repository2 = CRepository::NewL( KCRUidBluetoothEngine );
repository2->Get(KBTEnabledInOffline, aBTActivationEnabled);
RUBY_DEBUG1( "CVCApplicationControllerImpl::GetOfflineModeFlagsL: activation allowed %d", aBTActivationEnabled );
// Closing connection:
delete repository2;
}
// ----------------------------------------------------------
// CVCApplicationControllerImpl::GetSimcardMode
// ----------------------------------------------------------
//
void CVCApplicationControllerImpl::GetSIMCardMode( TInt& aSIMCardMode ) const
{
RUBY_DEBUG_BLOCKL( "CVCApplicationControllerImpl::GetSIMCardMode" );
// We are changing from Off-line to a normal profile.
// Check if SIM card exists or not
aSIMCardMode = ESimNotPresent;
RProperty simStatus;
simStatus.Attach( KPSUidStartup, KPSSimStatus );
simStatus.Get( aSIMCardMode );
simStatus.Close();
}
// ---------------------------------------------------------------------------
// CVCApplicationControllerImpl::ActivateMessageL
// ---------------------------------------------------------------------------
TInt CVCApplicationControllerImpl::ActivateMessageL(TEditorType aType)
{
RUBY_DEBUG_BLOCKL( "CVCApplicationControllerImpl::ActivateMessageL" );
TInt err = KErrNone;
TUid mtmType = KNullUid;
switch( aType )
{
case EEditorTypeNewMessage:
mtmType.iUid = KSenduiMtmUniMessageUidValue ;
break;
case EEditorTypeNewEmail:
mtmType.iUid = KSenduiMtmSmtpUidValue;
break;
case EEditorTypePostcard:
mtmType.iUid = KSenduiMtmPostcardUidValue;
break;
default:
err = KErrNotFound;
break;
}
if (!err)
{
MHandlesSendAppUi().CreateAndSendMessageL( mtmType,
NULL,
KNullUid,
EFalse );
}
return err;
}
// ---------------------------------------------------------------------------
// CVCApplicationControllerImpl::MHandlesSendAppUi()
// Returns send ui instance.
// ---------------------------------------------------------------------------
CSendUi& CVCApplicationControllerImpl::MHandlesSendAppUi()
{
if ( !iSendUi )
{
TRAPD( error, iSendUi = CSendUi::NewL() );
if ( error != KErrNone )
{
iSendUi = NULL;
}
}
return *iSendUi;
}
// ----------------------------------------------------
// CVCApplicationControllerImpl::HandleCurrentCallStatusChange
// Handle call status change event.
// ----------------------------------------------------
//
void CVCApplicationControllerImpl::HandleCurrentCallStatusChange()
{
switch( iPropertyHandler->Value() )
{
case EPSCTsyCallStateNone:
case EPSCTsyCallStateAlerting:
case EPSCTsyCallStateRinging:
{
switch (iState)
{
case EVoiceMail:
{
iCallStatus = ETrue;
// Cancel the menu
iVmbx.Close();
break;
}
case ENewMessage:
{
iCallStatus = ETrue;
// Cancel the menu
Cancel();
if (iCoeEnv && iEikonEnv->EikAppUi())
{
iEikonEnv->EikAppUi()->RemoveFromStack(this);
}
break;
}
case EQueryDialog:
{
iCallStatus = ETrue;
DismissQueryDialog();
break;
}
default:
// Pass
break;
}
break;
}
default:
{
// pass
break;
}
}
}
// ---------------------------------------------------------
// CVCApplicationControllerImpl::Cancel
// ---------------------------------------------------------
//
void CVCApplicationControllerImpl::Cancel()
{
// Cancel the menu
if ( iPopupList )
{
iPopupList->CancelPopup();
iPopupList = NULL;
}
}
// ---------------------------------------------------------
// CVCApplicationControllerImpl::OfferKeyEventL
// ---------------------------------------------------------
//
TKeyResponse CVCApplicationControllerImpl::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)
{
RUBY_DEBUG_BLOCKL( "CVCApplicationControllerImpl::OfferKeyEventL" );
TKeyResponse keyEvent( EKeyWasNotConsumed );
if ( aType == EEventKey && ( aKeyEvent.iScanCode == EStdKeyNo ||
aKeyEvent.iScanCode == EStdKeyApplication0 ) )
{
switch ( iState )
{
case EVoiceMail:
iVmbx.Close();
keyEvent = EKeyWasConsumed;
break;
case ENewMessage:
Cancel();
if ( iCoeEnv && iEikonEnv->EikAppUi() )
{
iEikonEnv->EikAppUi()->RemoveFromStack( this );
}
keyEvent = EKeyWasConsumed;
break;
case EQueryDialog:
DismissQueryDialog();
keyEvent = EKeyWasConsumed;
break;
default:
break;
}
}
return keyEvent;
}
// ---------------------------------------------------------
// CVCApplicationControllerImpl::HandleNotifyL
// ---------------------------------------------------------
//
TInt CVCApplicationControllerImpl::HandleNotifyL( TInt aCmdId, TInt /*aEventId*/,
CAiwGenericParamList& /*aEventParamList*/,
const CAiwGenericParamList& /*aInParamList*/ )
{
RUBY_DEBUG_BLOCKL( "CVCApplicationControllerImpl::HandleNotifyL" );
if ( aCmdId == KAiwCmdCall )
{
if ( iWait.IsStarted() )
{
iWait.AsyncStop();
}
}
return KErrNone;
}
// ---------------------------------------------------------
// CVCApplicationControllerImpl::HandleActiveObjectStatus
// ---------------------------------------------------------
//
void CVCApplicationControllerImpl::HandleActiveObjectStatus(TInt aStatus)
{
RUBY_DEBUG1( "CVCApplicationControllerImpl::HandleActiveObjectStatus() aStatus = %d", aStatus);
// Cancel active object and note.
iActiveObject->Cancel();
iGlobalConfQuery->CancelConfirmationQuery();
// Check that user pressed softkey YES
if ( (aStatus == EAknSoftkeyYes ||
aStatus == EAknSoftkeySelect ||
aStatus == EAknSoftkeyOk) &&
iProfileEngine )
{
TRAP_IGNORE( iProfileEngine->SetActiveProfileL( iProfileId ) );
}
}
// ----------------------------------------------------------------------------
// CVCApplicationControllerImpl::CreateConnectionL
// Connects to RApaLsSession.
// ----------------------------------------------------------------------------
//
void CVCApplicationControllerImpl::CreateApaConnectionL()
{
iApaLsSession = new RApaLsSession();
if ( !iApaLsSession->Handle() )
{
User::LeaveIfError( iApaLsSession->Connect() );
}
}
// ----------------------------------------------------------------------------
// CVCApplicationControllerImpl::ActivateAppL
// Used to launch applications. Checks whether an instance of the launched
// application is already running.
// ----------------------------------------------------------------------------
//
void CVCApplicationControllerImpl::ActivateAppL( const TUid aUid,
TBool aMultipleInstances )
{
CreateApaConnectionL();
if ( aMultipleInstances )
{
ActivateAppInstanceL( aUid );
}
else
{
// Session to window server
RWsSession wsSession;
User::LeaveIfError( wsSession.Connect() );
CleanupClosePushL( wsSession );
TApaTaskList apaTaskList( wsSession );
TApaTask apaTask = apaTaskList.FindApp( aUid );
if ( apaTask.Exists() )
{
// Already running, close application
apaTask.EndTask();
}
ActivateAppInstanceL( aUid );
CleanupStack::PopAndDestroy( &wsSession );
}
}
// ----------------------------------------------------------------------------
// CVCApplicationControllerImpl::ActivateAppInstanceL
// Activates an instance of an application.
// ----------------------------------------------------------------------------
//
void CVCApplicationControllerImpl::ActivateAppInstanceL( const TUid aUid )
{
TApaAppInfo appInfo;
User::LeaveIfError( iApaLsSession->GetAppInfo( appInfo, aUid ) );
TFileName appName = appInfo.iFullName;
CApaCommandLine* apaCommandLine = CApaCommandLine::NewLC();
apaCommandLine->SetExecutableNameL( appName );
apaCommandLine->SetCommandL( EApaCommandRun );
User::LeaveIfError ( iApaLsSession->StartApp( *apaCommandLine ) );
CleanupStack::PopAndDestroy( apaCommandLine );
}
// ----------------------------------------------------------------------------
// CVCApplicationControllerImpl::DismissQueryDialog
// Closes query dialog
// ----------------------------------------------------------------------------
//
void CVCApplicationControllerImpl::DismissQueryDialog()
{
if ( iQueryDialog )
{
iQueryDialog->MakeLeftSoftkeyVisible( EFalse );
TRAP_IGNORE( iQueryDialog->DismissQueryL() );
}
}
// End of File