diff -r 82ee1f804b63 -r 4c4ed41530db locationmapnavfw/aiwprovider/src/mnaiwprovider.cpp --- a/locationmapnavfw/aiwprovider/src/mnaiwprovider.cpp Mon May 03 12:54:42 2010 +0300 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,883 +0,0 @@ -/* -* 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: CMnAiwProvider class implementation -* -*/ - - -#include - -#include -#include - -#include -#include -#include -#include - -#include - -#include -#include "mnaiwprovideruids.hrh" - -#include - -#include -#include -#include -#include -#include -#include -#include - -#include "mnaiwdebug.h" -#include "mnaiwinternal.h" - -#include "mnaiwservices.h" -#include "mnaiwmenus.hrh" - -#include "mnaiwprovider.h" - -// =========================== LOCAL FUNCTIONS ================================= - -// --------------------------------------------------------------------------- -// Cleanup item for RPointerArray -// --------------------------------------------------------------------------- -// -void CleanupProvidersArray( TAny* aArray ) - { - ( static_cast*>( aArray ) )->ResetAndDestroy(); - } - -// --------------------------------------------------------------------------- -// Identity relation for providers. Based on UID -// --------------------------------------------------------------------------- -// -TBool ProvidersMatchByUid( const CMnProvider& aOne, const CMnProvider& aAnother ) - { - return ( aOne.Uid().iUid == aAnother.Uid().iUid ); - } - -// ========================== MEMBER FUNCTIONS ================================= - -// ----------------------------------------------------------------------------- -// ----------------------------------------------------------------------------- -// -CMnAiwProvider* CMnAiwProvider::NewL() - { - LOG( "CMnAiwProvider::NewL in" ); - - CMnAiwProvider* self = new (ELeave) CMnAiwProvider(); - CleanupStack::PushL(self); - self->ConstructL(); - CleanupStack::Pop(self); - - LOG( "CMnAiwProvider::NewL out" ); - return self; - } - -// ----------------------------------------------------------------------------- -// ----------------------------------------------------------------------------- -// -CMnAiwProvider::CMnAiwProvider() - { - } - -// ----------------------------------------------------------------------------- -// ----------------------------------------------------------------------------- -// -CMnAiwProvider::~CMnAiwProvider() - { - LOG( "~CMnAiwProvider in" ); - - delete iEventList; - - CloseAllHandlers(); - iHandlers.Close(); - - if ( iEikon ) - { - iEikon->DeleteResourceFile( iResourceOffset ); - } - iMnProviders.ResetAndDestroy(); - - LOG( "~CMnAiwProvider out" ); - } - - -// ----------------------------------------------------------------------------- -// ----------------------------------------------------------------------------- -// -void CMnAiwProvider::ConstructL() - { - LOG( "CMnAiwProvider::ConstructL in" ); -#ifdef _DEBUG - TTime start; - start.UniversalTime(); -#endif - - iEikon = CEikonEnv::Static(); - - TRAPD( err, MnUtils::FindLocalizedResourceFileL( iEikon->FsSession(), KAiwResourceFile, iResourceFilename ) ); - if ( err == KErrNotFound ) - { - // try to find it with the name it had in 3.1 - // this is needed for the case, when upgrade is installed on 3.1-based terminals - MnUtils::FindLocalizedResourceFileL( iEikon->FsSession(), KAiwResourceFileOld, iResourceFilename ); - } - iResourceOffset = iEikon->AddResourceFileL( iResourceFilename ); - - iEventList = CAiwGenericParamList::NewL(); - -#ifdef _DEBUG - TTime finish; - finish.UniversalTime(); - TTimeIntervalMicroSeconds elapsed = finish.MicroSecondsFrom( start ); - LOG1( "CMnAiwProvider::ConstructL out ( in %ld microseconds ) ", elapsed.Int64() ); -#endif - } - -// ----------------------------------------------------------------------------- -// ----------------------------------------------------------------------------- -// -TInt CMnAiwProvider::GetAiwServiceCommandIdL( const CAiwGenericParamList& aInParamList ) - { - TInt index = 0; - const TAiwGenericParam* param = aInParamList.FindFirst( index, EGenericParamServiceCommand ); - if ( index < 0 ) - { - LOG( "CMnAiwProvider::GetServiceCommandL: param not found" ); - User::Leave( KErrArgument ); - } - - TInt32 num = 0; - const TAiwVariant& val = param->Value(); - if ( !val.Get( num ) ) - { - LOG( "CMnAiwProvider::GetServiceCommandL: param value not found" ); - User::Leave( KErrArgument ); - } - return num; - } - -// ----------------------------------------------------------------------------- -// From CAiwServiceIfBase -// ----------------------------------------------------------------------------- -// -void CMnAiwProvider::InitialiseL( - MAiwNotifyCallback& /*aFrameworkCallback*/, - const RCriteriaArray& /*aInterest*/ ) - { - LOG("CMnAiwProvider::InitialiseL"); - } - -// ----------------------------------------------------------------------------- -// From CAiwServiceIfBase -// ----------------------------------------------------------------------------- -// -void CMnAiwProvider::HandleServiceCmdL( - const TInt& aCmdId, - const CAiwGenericParamList& aInParamList, - CAiwGenericParamList& aOutParamList, - TUint aCmdOptions, - const MAiwNotifyCallback* aCallback) - { - LOG1("CMnAiwProvider::HandleServiceCmdL cmdId: %x", aCmdId); - - if ( aCmdOptions & KAiwOptCancel ) - { - // this is call to cancel async request, - // not supported yet - ignoring, but not starting new one. - LOG("CMnAiwProvider::HandleServiceCmdL attempt to cancel, exit"); - return; - } - - CMnAiwCommandHandlerBase::TAiwParameters - aiwParams( aInParamList, aOutParamList, aCallback ); - - switch ( aCmdId ) - { - case KAiwCmdMnShowMap: - case KAiwCmdMnNavigateTo: - { - TInt err = KErrNone; - TBool stop = EFalse; - while ( !stop ) - { - TRAP( err, ProcessSyncAiwCommandL( aCmdId, aiwParams ) ); - ProcessAiwCommandResultL( aCmdId, aiwParams, err, stop ); - } - User::LeaveIfError( err ); - } - break; - - case KAiwCmdMnSelectFromMap: - case KAiwCmdMnCoordByAddr: - case KAiwCmdMnAddrByCoord: - if ( !aCallback ) - { - User::Leave( KErrArgument ); - } - StartAsyncAiwCommandL( aCmdId, aiwParams ); - break; - - default: - User::Leave( KErrNotSupported ); - break; - } - } - -// ----------------------------------------------------------------------------- -// ----------------------------------------------------------------------------- -// -void CMnAiwProvider::ProcessSyncAiwCommandL( - TInt aCommandId, - CMnAiwCommandHandlerBase::TAiwParameters& aAiwParams ) - { - LOG("CMnAiwProvider::ProcessSyncAiwCommandL in"); - - CMnAiwCommandHandlerBase* handler = HandlerL( aCommandId, aAiwParams ); - handler->StartL(); - - LOG("CMnAiwProvider::ProcessSyncAiwCommandL out"); - } - -// ----------------------------------------------------------------------------- -// ----------------------------------------------------------------------------- -// -void CMnAiwProvider::StartAsyncAiwCommandL( - TInt aCommandId, - CMnAiwCommandHandlerBase::TAiwParameters& aAiwParams ) - { - LOG("CMnAiwProvider::StartAsyncAiwCommandL in"); - - TBool stop = EFalse; - while ( !stop ) - { - TInt err = KErrNone; - CMnAiwCommandHandlerBase* handler = NULL; - TRAP( err, handler = HandlerL( aCommandId, aAiwParams ) ); - - if ( !err ) - { - handler->Start( *this ); - break; - } - else - { - if ( handler ) - { - CloseHandler( handler ); - } - - if ( err == KErrCancel ) - { - // must stop if provider selection fails - stop = ETrue; - } - else - { - // this is error from command start - ProcessAiwCommandResultL( aCommandId, aAiwParams, err, stop ); - } - - if ( stop ) - { - // couldn't start command - NotifyAiwObserver( aCommandId, aAiwParams, err ); - } - } - } - - LOG("CMnAiwProvider::StartAsyncAiwCommandL out"); - } - -// ----------------------------------------------------------------------------- -// ----------------------------------------------------------------------------- -// -CMnAiwCommandHandlerBase* CMnAiwProvider::HandlerL( - TInt aCommandId, - CMnAiwCommandHandlerBase::TAiwParameters& aAiwParams ) - { - LOG("CMnAiwProvider::HandlerL in"); - - CMnProvider& provider = SelectProviderL( aCommandId, aAiwParams ); - - CMnAiwCommandHandlerBase::TRunMode runMode = - CMnAiwCommandHandlerBase::RequestedRunModeL( aAiwParams ); - - if ( runMode == CMnAiwCommandHandlerBase::ERunModeDefault ) - { - runMode = CMnAiwCommandHandlerBase::DefaultRunMode( aCommandId ); - } - - if ( runMode == CMnAiwCommandHandlerBase::ERunModeDefault ) - { - User::Leave( KErrNotSupported ); - } - - CMnAiwCommandHandlerBase* handler = FindWorkingHandler( aCommandId, provider, runMode ); - - if ( !handler ) - { - handler = CMnAiwCommandHandlerBase::CreateHandlerL( aCommandId, provider, runMode ); - CleanupStack::PushL( handler ); - handler->SetExitObserverL( *this ); - iHandlers.AppendL( handler ); - CleanupStack::Pop( handler ); - } - else - { - LOG("CMnAiwProvider::HandlerL, working handler found, reusing"); - handler->ResetParametersL(); - } - - handler->SetParametersL( aAiwParams ); - - LOG("CMnAiwProvider::HandlerL out"); - return handler; - } - -// ----------------------------------------------------------------------------- -// ----------------------------------------------------------------------------- -// -void CMnAiwProvider::HandleAsyncAiwCmdCompletedL( - CMnAiwCommandHandlerBase* aHandler, - TInt aResult ) - { - LOG1("CMnAiwProvider::HandleAsyncAiwCmdCompletedL in, result %d", aResult ); - - TInt command = aHandler->CommandId(); - CMnAiwCommandHandlerBase::TAiwParameters aiwParams = aHandler->AiwParameters(); - - CloseHandler( aHandler ); - - TBool stop = EFalse; - ProcessAiwCommandResultL( command, aiwParams, aResult, stop ); - - if ( stop ) - { - NotifyAiwObserver( command, aiwParams, aResult ); - } - else - { - StartAsyncAiwCommandL( command, aiwParams ); - } - - LOG("CMnAiwProvider::HandleAsyncAiwCmdCompletedL out"); - } - -// ----------------------------------------------------------------------------- -// ----------------------------------------------------------------------------- -// -void CMnAiwProvider::HandleProviderExit( - CMnAiwCommandHandlerBase* aHandler ) - { - LOG("CMnAiwProvider::HandleProviderExit in" ); - - CloseHandler( aHandler ); - - LOG("CMnAiwProvider::HandleProviderExit out"); - } - -// ----------------------------------------------------------------------------- -// ----------------------------------------------------------------------------- -// -void CMnAiwProvider::NotifyAiwObserver( - TInt aCommandId, - CMnAiwCommandHandlerBase::TAiwParameters& aAiwParams, - TInt aResult ) - { - LOG2("CMnAiwProvider::NotifyAiwObserver in, command 0x%X, result %d", aCommandId, aResult); - __ASSERT_DEBUG( aAiwParams.Callback(), Panic( KErrGeneral) ); - - MAiwNotifyCallback* callback = const_cast( aAiwParams.Callback() ); - - TInt err = KErrNone; - iEventList->Reset(); - if ( aResult ) - { - TAiwGenericParam error( EGenericParamError, TAiwVariant( aResult ) ); - TRAP_IGNORE( iEventList->AppendL( error ) ); - - TRAP( err, callback->HandleNotifyL( - aCommandId, KAiwEventError, *iEventList, aAiwParams.InList() ) ); - } - else - { - TRAP( err, callback->HandleNotifyL( - aCommandId, KAiwEventCompleted, *iEventList, aAiwParams.InList() ) ); - } - - LOG("CMnAiwProvider::NotifyAiwObserver out"); - } - -// ----------------------------------------------------------------------------- -// ----------------------------------------------------------------------------- -// -void CMnAiwProvider::CloseHandler( CMnAiwCommandHandlerBase* aHandler ) - { - LOG("CMnAiwProvider::CloseHandler in"); - - if ( aHandler->IsActive() ) - { - // make sure we are not panicked if async handler is closed while active. - // at first, command is only cancelled. Cancel will call this method again, - // then this object will be deleted. - aHandler->Cancel(); - } - - TInt index = iHandlers.Find( aHandler ); - if ( index != KErrNotFound ) - { - delete aHandler; - iHandlers.Remove( index ); - } - LOG1("CMnAiwProvider::CloseHandler out, deleted handler %d", index); - } - -// ----------------------------------------------------------------------------- -// ----------------------------------------------------------------------------- -// -void CMnAiwProvider::ProcessAiwCommandResultL( - TInt aAiwCommandId, - CMnAiwCommandHandlerBase::TAiwParameters& aAiwParams, - TInt aResult, - TBool& aStop ) - { - LOG1("CMnAiwProvider::ProcessAiwCommandResultL in, result %d", aResult); - - TBool banMessages = EFalse; - if ( CMnAiwCommandHandlerBase::IsErrorMessageDisabledL( aAiwParams ) ) - { - banMessages = ETrue; - } - - TInt unusedProviderId( 0 ); - TInt messageId( 0 ); - - if ( aResult == KErrNone || aResult == KErrCancel ) - { - aStop = ETrue; - } - else if ( CMnAiwCommandHandlerBase::IsProviderSpecifiedL( aAiwParams, unusedProviderId ) ) - { - aStop = ETrue; - messageId = R_MN_ERROR_SERVICE_UNAVAILABLE; - } - else if ( NumSuitableProviders( aAiwCommandId ) < 2 ) - { - aStop = ETrue; - messageId = R_MN_ERROR_NO_PROVIDER; - } - else - { - aStop = EFalse; - messageId = R_MN_ERROR_SERVICE_UNAVAILABLE; - } - - if ( !banMessages && messageId ) - { - ErrorNote( messageId ); - } - - LOG("CMnAiwProvider::ProcessAiwCommandResultL out"); - } - -// ----------------------------------------------------------------------------- -// From CAiwServiceIfMenu -// ----------------------------------------------------------------------------- -// -void CMnAiwProvider::InitializeMenuPaneL( - CAiwMenuPane& aMenuPane, - TInt aIndex, - TInt /*aCascadeId*/, - const CAiwGenericParamList& aInParamList) - { - LOG( "CMnAiwProvider::InitializeMenuPaneL in" ); - - TInt svcCmdId = GetAiwServiceCommandIdL( aInParamList ); - if ( !IsServiceAvailableL( svcCmdId ) ) - { - LOG1( "CMnAiwProvider::InitializeMenuPaneL svc 0x%X is not available, out", svcCmdId ); - return; - } - - switch ( svcCmdId ) - { - case KAiwCmdMnShowMap: - aMenuPane.AddMenuItemsL( - iResourceFilename, - R_MN_AIWMENU_SHOW_ON_MAP, - KAiwCmdMnShowMap, - aIndex); - break; - - case KAiwCmdMnSelectFromMap: - aMenuPane.AddMenuItemsL( - iResourceFilename, - R_MN_AIWMENU_SELECT_FROM_MAP, - KAiwCmdMnSelectFromMap, - aIndex); - break; - - case KAiwCmdMnNavigateTo: - aMenuPane.AddMenuItemsL( - iResourceFilename, - R_MN_AIWMENU_NAVIGATE_TO, - KAiwCmdMnNavigateTo, - aIndex); - break; - - case KAiwCmdMnCoordByAddr: - aMenuPane.AddMenuItemsL( - iResourceFilename, - R_MN_AIWMENU_FETCH_COORDINATES, - KAiwCmdMnCoordByAddr, - aIndex); - break; - - case KAiwCmdMnAddrByCoord: - aMenuPane.AddMenuItemsL( - iResourceFilename, - R_MN_AIWMENU_FETCH_ADDRESS, - KAiwCmdMnAddrByCoord, - aIndex); - break; - } - LOG( "CMnAiwProvider::InitializeMenuPaneL out" ); - } - - -// ----------------------------------------------------------------------------- -// From CAiwServiceIfMenu -// ----------------------------------------------------------------------------- -// -void CMnAiwProvider::HandleMenuCmdL( - TInt aMenuCmdId, - const CAiwGenericParamList& aInParamList, - CAiwGenericParamList& aOutParamList, - TUint aCmdOptions, - const MAiwNotifyCallback* aCallback) - { - LOG( "CMnAiwProvider::HandleMenuCmdL in" ); - - TInt svcCmdId = KAiwCmdNone; - - switch ( aMenuCmdId ) - { - case EMnAiwMenuCmdShowOnMap: - svcCmdId = KAiwCmdMnShowMap; - break; - - case EMnAiwMenuCmdSelectFromMap: - svcCmdId = KAiwCmdMnSelectFromMap; - break; - - case EMnAiwMenuCmdNavigateTo: - svcCmdId = KAiwCmdMnNavigateTo; - break; - - case EMnAiwMenuCmdFetchAddress: - svcCmdId = KAiwCmdMnAddrByCoord; - break; - - case EMnAiwMenuCmdFetchCoordinates: - svcCmdId = KAiwCmdMnCoordByAddr; - break; - } - - HandleServiceCmdL( svcCmdId, aInParamList, aOutParamList, aCmdOptions, aCallback ); - - LOG( "CMnAiwProvider::HandleMenuCmdL out" ); - } - -// ----------------------------------------------------------------------------- -// ----------------------------------------------------------------------------- -// -TBool CMnAiwProvider::IsServiceAvailableL( TInt aAiwCommandId ) - { - UpdateProvidersListL(); - return NumSuitableProviders( aAiwCommandId ) > 0; - } - -// ----------------------------------------------------------------------------- -// ----------------------------------------------------------------------------- -// -void CMnAiwProvider::UpdateProvidersListL() - { - // get new list of providers - RPointerArray providers; - CleanupStack::PushL( TCleanupItem( CleanupProvidersArray, &providers ) ); - MnProviderFinder::FindProvidersL( providers ); - - // merge new list with current list of providers - TIdentityRelation byUid( ProvidersMatchByUid ); - - // detect removed providers - for ( TInt i = iMnProviders.Count() - 1; i >= 0 ; i-- ) - { - if ( providers.Find( iMnProviders[i], byUid ) == KErrNotFound ) - { - LOG1("CMnAiwProvider::UpdateProvidersListL, provider 0x%X removed", - iMnProviders[i]->Uid().iUid ); - CloseHandlers( iMnProviders[i] ); - delete iMnProviders[i]; - iMnProviders.Remove( i ); - } - } - - // detect new providers - for ( TInt i = providers.Count() - 1; i >=0 ; i-- ) - { - if ( iMnProviders.Find( providers[i], byUid ) == KErrNotFound ) - { - LOG1("CMnAiwProvider::UpdateProvidersListL, new provider 0x%X added", - providers[i]->Uid().iUid ); - iMnProviders.AppendL( providers[i] ); - providers.Remove( i ); // ownership is moved to iMnProviders - } - } - - CleanupStack::PopAndDestroy( &providers ); - } - -// ----------------------------------------------------------------------------- -// ----------------------------------------------------------------------------- -// -CMnAiwCommandHandlerBase* CMnAiwProvider::FindWorkingHandler( - TInt aAiwCommandId, - const CMnProvider& aProvider, - CMnAiwCommandHandlerBase::TRunMode aRunMode ) - { - for ( TInt i = 0; i < iHandlers.Count(); i++ ) - { - CMnAiwCommandHandlerBase* handler = iHandlers[i]; - if ( handler->Provider().Uid() == aProvider.Uid() && - handler->CommandId() == aAiwCommandId && - handler->RunMode() == aRunMode && - !handler->IsActive() ) // active async handler cannot be reused - { - return iHandlers[i]; - } - } - return NULL; - } - -// ----------------------------------------------------------------------------- -// ----------------------------------------------------------------------------- -// -void CMnAiwProvider::CloseHandlers( const CMnProvider* aProvider ) - { - for ( TInt i = iHandlers.Count() - 1; i >= 0 ; i-- ) - { - if ( ProvidersMatchByUid( iHandlers[i]->Provider(), *aProvider ) ) - { - CloseHandler( iHandlers[i] ); // this will modify the handlers list - } - } - } - -// ----------------------------------------------------------------------------- -// ----------------------------------------------------------------------------- -// -void CMnAiwProvider::CloseAllHandlers() - { - for ( TInt i = iHandlers.Count() - 1; i >= 0 ; i-- ) - { - CloseHandler( iHandlers[i] ); // this will modify the handlers list - } - } - -// ----------------------------------------------------------------------------- -// ----------------------------------------------------------------------------- -// -void CMnAiwProvider::GetSuitableProvidersL( - TInt aAiwCommandId, - RPointerArray& aProviders ) - { - LOG1("CMnAiwProvider::GetSuitableProvidersL in, Cmd %x", aAiwCommandId); - - CMnProvider::TService serviceNeeded = CMnProvider::EServiceNone; - TInt featuresNeeded = 0; - - CMnAiwCommandHandlerBase::AppServiceAndFeatureNeeded( - aAiwCommandId, serviceNeeded, featuresNeeded ); - - for ( TInt i = 0; i < iMnProviders.Count(); i++ ) - { - CMnProvider* provider = iMnProviders[i]; - - if ( ( provider->SupportedServices() & serviceNeeded ) && - ( provider->SupportedFeatures( serviceNeeded ) & featuresNeeded ) ) - { - LOG1("CMnAiwProvider::GetSuitableProvidersL using 0x%X", provider->Uid().iUid); - aProviders.AppendL( provider ); - } - } - LOG("CMnAiwProvider::GetSuitableProvidersL out"); - } - -// ----------------------------------------------------------------------------- -// ----------------------------------------------------------------------------- -// -TInt CMnAiwProvider::NumSuitableProviders( TInt aAiwCommandId ) - { - CMnProvider::TService serviceNeeded = CMnProvider::EServiceNone; - TInt featuresNeeded = 0; - - CMnAiwCommandHandlerBase::AppServiceAndFeatureNeeded( - aAiwCommandId, serviceNeeded, featuresNeeded ); - - TInt count = 0; - for ( TInt i = 0; i < iMnProviders.Count(); i++ ) - { - CMnProvider* provider = iMnProviders[i]; - - if ( ( provider->SupportedServices() & serviceNeeded ) && - ( provider->SupportedFeatures( serviceNeeded ) & featuresNeeded ) ) - { - count++; - } - } - return count; - } - -// ----------------------------------------------------------------------------- -// ----------------------------------------------------------------------------- -// -CMnProvider& CMnAiwProvider::SelectProviderL( - TInt aAiwCommandId, - CMnAiwCommandHandlerBase::TAiwParameters& aAiwParams ) - { - CMnProvider* provider = NULL; - - RPointerArray mnProviders; // array does _not_ own items - CleanupClosePushL( mnProviders ); - - UpdateProvidersListL(); - GetSuitableProvidersL( aAiwCommandId, mnProviders ); - - TInt requestedProviderId( 0 ); - if ( CMnAiwCommandHandlerBase::IsProviderSpecifiedL( aAiwParams, requestedProviderId ) ) - { - for ( int i = 0; i < mnProviders.Count(); i++ ) - { - if ( mnProviders[i]->Uid().iUid == requestedProviderId ) - { - provider = mnProviders[i]; - break; - } - } - - if ( !provider ) - { - User::Leave( KErrArgument ); - } - } - else if ( mnProviders.Count() > 1 ) - { - TInt index = KErrNotFound; - ExecuteSelectionDialogL( index, mnProviders ); - provider = mnProviders[index]; - } - else if ( mnProviders.Count() == 1 ) - { - provider = mnProviders[0]; - } - else - { - User::Leave( KErrNotSupported ); - } - - CleanupStack::PopAndDestroy( &mnProviders ); - LOG1("CMnAiwProvider::SelectProviderL, selected 0x%X", provider->Uid().iUid); - return *provider; - } - -// ----------------------------------------------------------------------------- -// ----------------------------------------------------------------------------- -// -void CMnAiwProvider::ExecuteSelectionDialogL( - TInt& aIndex, - RPointerArray& aProviders ) - { - CDesCArraySeg* textArray = new (ELeave) CDesCArraySeg( aProviders.Count() ); - CleanupStack::PushL( textArray ); - - for ( TInt i = 0; i < aProviders.Count(); i++ ) - { - TPtrC shortName; - aProviders[i]->GetShortName( shortName ); - textArray->AppendL( shortName ); - } - - CAknListQueryDialog* dlg = new (ELeave) CAknListQueryDialog( &aIndex ); - dlg->PrepareLC( R_MN_PROVIDER_LIST_QUERY ); - - dlg->SetItemTextArray( textArray ); - dlg->SetOwnershipType( ELbmOwnsItemArray ); - - TInt result = dlg->RunLD(); - CleanupStack::Pop( textArray ); - - if ( !result ) - { - User::Leave( KErrCancel ); - } - } - -// ----------------------------------------------------------------------------- -// ----------------------------------------------------------------------------- -// -void CMnAiwProvider::ErrorNote( TInt aResourceId ) - { - TRAP_IGNORE( DoErrorNoteL( aResourceId ) ); - } - -// ----------------------------------------------------------------------------- -// ----------------------------------------------------------------------------- -// -void CMnAiwProvider::DoErrorNoteL( TInt aResourceId ) - { - HBufC* noteText = iEikon->AllocReadResourceLC( aResourceId ); - - CAknGlobalNote* note = CAknGlobalNote::NewLC(); - note->ShowNoteL( EAknGlobalErrorNote, *noteText ); - CleanupStack::PopAndDestroy( note ); - - CleanupStack::PopAndDestroy( noteText ); - } - -// ======== GLOBAL FUNCTIONS ======== - -// ----------------------------------------------------------------------------- -// Map the interface UIDs to implementation factory functions -// ----------------------------------------------------------------------------- -// -const TImplementationProxy ImplementationTable[] = - { - IMPLEMENTATION_PROXY_ENTRY( KMnAiwProviderBaseImplUid, CMnAiwProvider::NewL ), - IMPLEMENTATION_PROXY_ENTRY( KMnAiwProviderMenuImplUid, CMnAiwProvider::NewL ) - }; - -// ----------------------------------------------------------------------------- -// Exported proxy for instantiation method resolution -// ----------------------------------------------------------------------------- -// -EXPORT_C const TImplementationProxy* ImplementationGroupProxy( TInt& aTableCount ) - { - aTableCount = ( sizeof ImplementationTable ) / sizeof( TImplementationProxy ); - return ImplementationTable; - }